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

#define SWIGRUBY
#define SWIG_DIRECTORS


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
  
  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


/* 
   Flags/methods for returning states.
   
   The SWIG conversion methods, as ConvertPtr, return an integer 
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).
   
   Use the following macros/flags to set or process the returning
   states.
   
   In old versions of SWIG, code such as the following was usually written:

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

   Now you can be more explicit:

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

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

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }
    
   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

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

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

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

       int food(double)
       int fooi(int);

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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


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

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

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

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

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

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

/* 
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;
  
  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }    
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}
  
/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)
  
  We start searching at module start, and finish searching when start == end.  
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start, 
                            swig_module_info *end, 
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      register size_t l = 0;
      register size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	register size_t i = (l + r) >> 1; 
	const char *iname = iter->types[i]->name;
	if (iname) {
	  register int compare = strcmp(name, iname);
	  if (compare == 0) {	    
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



#include <ruby.h>

/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
 * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
 * issue for now by disabling this.
 * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
 */
#ifdef rb_intern
# undef rb_intern
#endif

/* Remove global macros defined in Ruby's win32.h */
#ifdef write
# undef write
#endif
#ifdef read
# undef read
#endif
#ifdef bind
# undef bind
#endif
#ifdef close
# undef close
#endif
#ifdef connect
# undef connect
#endif


/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
#ifndef NUM2LL
#define NUM2LL(x) NUM2LONG((x))
#endif
#ifndef LL2NUM
#define LL2NUM(x) INT2NUM((long) (x))
#endif
#ifndef ULL2NUM
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
#endif

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
#ifndef NUM2ULL
#ifdef HAVE_LONG_LONG
#define NUM2ULL(x) rb_num2ull((x))
#else
#define NUM2ULL(x) NUM2ULONG(x)
#endif
#endif

/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
/* Define these for older versions so we can just write code the new way */
#ifndef RSTRING_LEN
# define RSTRING_LEN(x) RSTRING(x)->len
#endif
#ifndef RSTRING_PTR
# define RSTRING_PTR(x) RSTRING(x)->ptr
#endif
#ifndef RSTRING_END
# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
#endif
#ifndef RARRAY_LEN
# define RARRAY_LEN(x) RARRAY(x)->len
#endif
#ifndef RARRAY_PTR
# define RARRAY_PTR(x) RARRAY(x)->ptr
#endif
#ifndef RFLOAT_VALUE
# define RFLOAT_VALUE(x) RFLOAT(x)->value
#endif
#ifndef DOUBLE2NUM
# define DOUBLE2NUM(x) rb_float_new(x)
#endif
#ifndef RHASH_TBL
# define RHASH_TBL(x) (RHASH(x)->tbl)
#endif
#ifndef RHASH_ITER_LEV
# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
#endif
#ifndef RHASH_IFNONE
# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
#endif
#ifndef RHASH_SIZE
# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
#endif
#ifndef RHASH_EMPTY_P
# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
#endif
#ifndef RSTRUCT_LEN
# define RSTRUCT_LEN(x) RSTRUCT(x)->len
#endif
#ifndef RSTRUCT_PTR
# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
#endif



/*
 * Need to be very careful about how these macros are defined, especially
 * when compiling C++ code or C code with an ANSI C compiler.
 *
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
 * a Ruby method so that it can be passed as an argument to API functions
 * like rb_define_method() and rb_define_singleton_method().
 *
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
 * can be passed as an argument to API functions like Data_Wrap_Struct()
 * and Data_Make_Struct().
 */
 
#ifdef __cplusplus
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
#    define PROTECTFUNC(f) ((VALUE (*)()) f)
#    define VALUEFUNC(f) ((VALUE (*)()) f)
#    define VOIDFUNC(f)  ((void (*)()) f)
#  else
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
#      define PROTECTFUNC(f) ((VALUE (*)()) f)
#      define VALUEFUNC(f) ((VALUE (*)()) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    else /* These definitions should work for Ruby 1.7+ */
#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    endif
#  endif
#else
#  define VALUEFUNC(f) (f)
#  define VOIDFUNC(f) (f)
#endif

/* Don't use for expressions have side effect */
#ifndef RB_STRING_VALUE
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#endif
#ifndef StringValue
#define StringValue(s) RB_STRING_VALUE(s)
#endif
#ifndef StringValuePtr
#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
#endif
#ifndef StringValueLen
#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
#endif
#ifndef SafeStringValue
#define SafeStringValue(v) do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)
#endif

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
#endif

static VALUE _mSWIG = Qnil;

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


/* Define some additional error types */
#define SWIG_ObjectPreviouslyDeletedError  -100


/* Define custom exceptions for errors that do not map to existing Ruby
   exceptions.  Note this only works for C++ since a global cannot be
   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/

SWIGINTERN VALUE 
getNullReferenceError(void) {
  static int init = 0;
  static VALUE rb_eNullReferenceError ;
  if (!init) {
    init = 1;
    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
  }
  return rb_eNullReferenceError;
} 

SWIGINTERN VALUE 
getObjectPreviouslyDeletedError(void) {
  static int init = 0;
  static VALUE rb_eObjectPreviouslyDeleted ;
  if (!init) {
    init = 1;
    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
  }
  return rb_eObjectPreviouslyDeleted;
} 


SWIGINTERN VALUE
SWIG_Ruby_ErrorType(int SWIG_code) {
  VALUE type;
  switch (SWIG_code) {
  case SWIG_MemoryError:
    type = rb_eNoMemError;
    break;
  case SWIG_IOError:
    type = rb_eIOError;
    break;
  case SWIG_RuntimeError:
    type = rb_eRuntimeError;
    break;
  case SWIG_IndexError:
    type = rb_eIndexError;
    break;
  case SWIG_TypeError:
    type = rb_eTypeError;
    break;
  case SWIG_DivisionByZero:
    type = rb_eZeroDivError;
    break;
  case SWIG_OverflowError:
    type = rb_eRangeError;
    break;
  case SWIG_SyntaxError:
    type = rb_eSyntaxError;
    break;
  case SWIG_ValueError:
    type = rb_eArgError;
    break;
  case SWIG_SystemError:
    type = rb_eFatal;
    break;
  case SWIG_AttributeError:
    type = rb_eRuntimeError;
    break;
  case SWIG_NullReferenceError:
    type = getNullReferenceError();
    break;
  case SWIG_ObjectPreviouslyDeletedError:
    type = getObjectPreviouslyDeletedError();
    break;
  case SWIG_UnknownError:
    type = rb_eRuntimeError;
    break;
  default:
    type = rb_eRuntimeError;
  }
  return type;
}


/* This function is called when a user inputs a wrong argument to
   a method.
 */
SWIGINTERN 
const char* Ruby_Format_TypeError( const char* msg,
				   const char* type, 
				   const char* name, 
				   const int argn,
				   VALUE input )
{
  char buf[128];
  VALUE str;
  VALUE asStr;
  if ( msg && *msg )
    {
      str = rb_str_new2(msg);
    }
  else
    {
      str = rb_str_new(NULL, 0);
    }

  str = rb_str_cat2( str, "Expected argument " );
  sprintf( buf, "%d of type ", argn-1 );
  str = rb_str_cat2( str, buf );
  str = rb_str_cat2( str, type );
  str = rb_str_cat2( str, ", but got " );
  str = rb_str_cat2( str, rb_obj_classname(input) );
  str = rb_str_cat2( str, " " );
  asStr = rb_inspect(input);
  if ( RSTRING_LEN(asStr) > 30 )
    {
      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
      str = rb_str_cat2( str, "..." );
    }
  else
    {
      str = rb_str_append( str, asStr );
    }

  if ( name )
    {
      str = rb_str_cat2( str, "\n\tin SWIG method '" );
      str = rb_str_cat2( str, name );
      str = rb_str_cat2( str, "'" );
    }

  return StringValuePtr( str );
}

/* This function is called when an overloaded method fails */
SWIGINTERN 
void Ruby_Format_OverloadedError(
				 const int argc,
				 const int maxargs,
				 const char* method, 
				 const char* prototypes 
				 )
{
  const char* msg = "Wrong # of arguments";
  if ( argc <= maxargs ) msg = "Wrong arguments";
  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
	   "Possible C/C++ prototypes are:\n%s",
	   msg, method, prototypes);
}

/* -----------------------------------------------------------------------------
 * rubytracking.swg
 *
 * This file contains support for tracking mappings from 
 * Ruby objects to C++ objects.  This functionality is needed
 * to implement mark functions for Ruby's mark and sweep
 * garbage collector.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* Ruby 1.8 actually assumes the first case. */
#if SIZEOF_VOIDP == SIZEOF_LONG
#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
#else
#  error sizeof(void*) is not the same as long or long long
#endif


/* Global Ruby hash table to store Trackings from C/C++
   structs to Ruby Objects. 
*/
static VALUE swig_ruby_trackings = Qnil;

/* Global variable that stores a reference to the ruby
   hash table delete function. */
static ID swig_ruby_hash_delete;

/* Setup a Ruby hash table to store Trackings */
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
  /* Create a ruby hash table to store Trackings from C++ 
     objects to Ruby objects. */

  /* Try to see if some other .so has already created a 
     tracking hash table, which we keep hidden in an instance var
     in the SWIG module.
     This is done to allow multiple DSOs to share the same
     tracking table.
  */
  ID trackings_id = rb_intern( "@__trackings__" );
  VALUE verbose = rb_gv_get("VERBOSE");
  rb_gv_set("VERBOSE", Qfalse);
  swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
  rb_gv_set("VERBOSE", verbose);

  /* No, it hasn't.  Create one ourselves */ 
  if ( swig_ruby_trackings == Qnil )
    {
      swig_ruby_trackings = rb_hash_new();
      rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
    }

  /* Now store a reference to the hash table delete function
     so that we only have to look it up once.*/
  swig_ruby_hash_delete = rb_intern("delete");
}

/* Get a Ruby number to reference a pointer */
SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
  /* We cast the pointer to an unsigned long
     and then store a reference to it using
     a Ruby number object. */

  /* Convert the pointer to a Ruby number */
  return SWIG2NUM(ptr);
}

/* Get a Ruby number to reference an object */
SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
  /* We cast the object to an unsigned long
     and then store a reference to it using
     a Ruby number object. */

  /* Convert the Object to a Ruby number */
  return SWIG2NUM(object);
}

/* Get a Ruby object from a previously stored reference */
SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
  /* The provided Ruby number object is a reference
     to the Ruby object we want.*/

  /* Convert the Ruby number to a Ruby object */
  return NUM2SWIG(reference);
}

/* Add a Tracking from a C/C++ struct to a Ruby object */
SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
  /* In a Ruby hash table we store the pointer and
     the associated Ruby object.  The trick here is
     that we cannot store the Ruby object directly - if
     we do then it cannot be garbage collected.  So
     instead we typecast it as a unsigned long and
     convert it to a Ruby number object.*/

  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Get a reference to the Ruby object as a Ruby number */
  VALUE value = SWIG_RubyObjectToReference(object);

  /* Store the mapping to the global hash table. */
  rb_hash_aset(swig_ruby_trackings, key, value);
}

/* Get the Ruby object that owns the specified C/C++ struct */
SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Now lookup the value stored in the global hash table */
  VALUE value = rb_hash_aref(swig_ruby_trackings, key);
	
  if (value == Qnil) {
    /* No object exists - return nil. */
    return Qnil;
  }
  else {
    /* Convert this value to Ruby object */
    return SWIG_RubyReferenceToObject(value);
  }
}

/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
   is very important to remove objects once they are destroyed
   since the same memory address may be reused later to create
   a new object. */
SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Delete the object from the hash table by calling Ruby's
     do this we need to call the Hash.delete method.*/
  rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
}

/* This is a helper method that unlinks a Ruby object from its
   underlying C++ object.  This is needed if the lifetime of the
   Ruby object is longer than the C++ object */
SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
  VALUE object = SWIG_RubyInstanceFor(ptr);

  if (object != Qnil) {
    DATA_PTR(object) = 0;
  }
}


#ifdef __cplusplus
}
#endif

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

#ifdef __cplusplus
extern "C" {
#endif

SWIGINTERN VALUE
SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
  if (NIL_P(target)) {
    target = o;
  } else {
    if (TYPE(target) != T_ARRAY) {
      VALUE o2 = target;
      target = rb_ary_new();
      rb_ary_push(target, o2);
    }
    rb_ary_push(target, o);
  }
  return target;
}

/* For ruby1.8.4 and earlier. */
#ifndef RUBY_INIT_STACK
   RUBY_EXTERN void Init_stack(VALUE* addr);
#  define RUBY_INIT_STACK \
   VALUE variable_in_this_stack_frame; \
   Init_stack(&variable_in_this_stack_frame);
#endif


#ifdef __cplusplus
}
#endif


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

/* For backward compatibility only */
#define SWIG_POINTER_EXCEPTION  0

/* for raw pointers */
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
#define swig_owntype                                    ruby_owntype

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_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_ConvertPtr(obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)

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


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule()	
#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)


/* Error manipulation */

#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
#define SWIG_fail                        		goto fail				 


/* Ruby-specific SWIG API */

#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  

#include "assert.h"

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

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
  VALUE klass;
  VALUE mImpl;
  void  (*mark)(void *);
  void  (*destroy)(void *);
  int trackObjects;
} swig_class;


/* Global pointer used to keep some internal SWIG stuff */
static VALUE _cSWIG_Pointer = Qnil;
static VALUE swig_runtime_data_type_pointer = Qnil;

/* Global IDs used to keep some internal SWIG stuff */
static ID swig_arity_id = 0;
static ID swig_call_id  = 0;

/*
  If your swig extension is to be run within an embedded ruby and has
  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
  This will reset ruby's stack frame on each entry point from the main 
  program the first time a virtual director function is invoked (in a 
  non-recursive way).
  If this is not done, you run the risk of Ruby trashing the stack.
*/

#ifdef RUBY_EMBEDDED

#  define SWIG_INIT_STACK                            \
      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
      ++swig_virtual_calls;
#  define SWIG_RELEASE_STACK --swig_virtual_calls;
#  define Ruby_DirectorTypeMismatchException(x) \
          rb_raise( rb_eTypeError, "%s", x ); return c_result;

      static unsigned int swig_virtual_calls = 0;

#else  /* normal non-embedded extension */

#  define SWIG_INIT_STACK
#  define SWIG_RELEASE_STACK
#  define Ruby_DirectorTypeMismatchException(x) \
          throw Swig::DirectorTypeMismatchException( x );

#endif  /* RUBY_EMBEDDED */


SWIGRUNTIME VALUE 
getExceptionClass(void) {
  static int init = 0;
  static VALUE rubyExceptionClass ;
  if (!init) {
    init = 1;
    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
  }
  return rubyExceptionClass;
} 

/* This code checks to see if the Ruby object being raised as part
   of an exception inherits from the Ruby class Exception.  If so,
   the object is simply returned.  If not, then a new Ruby exception
   object is created and that will be returned to Ruby.*/
SWIGRUNTIME VALUE
SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
  VALUE exceptionClass = getExceptionClass();
  if (rb_obj_is_kind_of(obj, exceptionClass)) {
    return obj;
  }  else {
    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
  }
}

/* Initialize Ruby runtime support */
SWIGRUNTIME void
SWIG_Ruby_InitRuntime(void)
{
  if (_mSWIG == Qnil) {
    _mSWIG = rb_define_module("SWIG");
    swig_call_id  = rb_intern("call");
    swig_arity_id = rb_intern("arity");
  }
}

/* Define Ruby class for C type */
SWIGRUNTIME void
SWIG_Ruby_define_class(swig_type_info *type)
{
  VALUE klass;
  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
  sprintf(klass_name, "TYPE%s", type->name);
  if (NIL_P(_cSWIG_Pointer)) {
    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
  }
  klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
  free((void *) klass_name);
}

/* Create a new pointer object */
SWIGRUNTIME VALUE
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
{
  int own =  flags & SWIG_POINTER_OWN; 
  int track;
  char *klass_name;
  swig_class *sklass;
  VALUE klass;
  VALUE obj;
  
  if (!ptr)
    return Qnil;
  
  if (type->clientdata) {
    sklass = (swig_class *) type->clientdata;
		
    /* Are we tracking this class and have we already returned this Ruby object? */
    track = sklass->trackObjects;
    if (track) {
      obj = SWIG_RubyInstanceFor(ptr);
      
      /* Check the object's type and make sure it has the correct type.
        It might not in cases where methods do things like 
        downcast methods. */
      if (obj != Qnil) {
        VALUE value = rb_iv_get(obj, "@__swigtype__");
        char* type_name = RSTRING_PTR(value);
				
        if (strcmp(type->name, type_name) == 0) {
          return obj;
        }
      }
    }

    /* Create a new Ruby object */
    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
			   ( own ? VOIDFUNC(sklass->destroy) : 
			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
			     ), ptr);

    /* If tracking is on for this class then track this object. */
    if (track) {
      SWIG_RubyAddTracking(ptr, obj);
    }
  } else {
    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    sprintf(klass_name, "TYPE%s", type->name);
    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
    free((void *) klass_name);
    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
  }
  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
  
  return obj;
}

/* Create a new class instance (always owned) */
SWIGRUNTIME VALUE
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
{
  VALUE obj;
  swig_class *sklass = (swig_class *) type->clientdata;
  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
  return obj;
}

/* Get type mangle from class name */
SWIGRUNTIMEINLINE char *
SWIG_Ruby_MangleStr(VALUE obj)
{
  VALUE stype = rb_iv_get(obj, "@__swigtype__");
  return StringValuePtr(stype);
}

/* Acquire a pointer value */
typedef void (*ruby_owntype)(void*);

SWIGRUNTIME ruby_owntype
SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
  if (obj) {
    ruby_owntype oldown = RDATA(obj)->dfree;
    RDATA(obj)->dfree = own;
    return oldown;
  } else {
    return 0;
  }
}

/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
{
  char *c;
  swig_cast_info *tc;
  void *vptr = 0;

  /* Grab the pointer */
  if (NIL_P(obj)) {
    *ptr = 0;
    return SWIG_OK;
  } else {
    if (TYPE(obj) != T_DATA) {
      return SWIG_ERROR;
    }
    Data_Get_Struct(obj, void, vptr);
  }
  
  if (own) *own = RDATA(obj)->dfree;
    
  /* Check to see if the input object is giving up ownership
     of the underlying C struct or C++ object.  If so then we
     need to reset the destructor since the Ruby object no 
     longer owns the underlying C++ object.*/ 
  if (flags & SWIG_POINTER_DISOWN) {
    /* Is tracking on for this class? */
    int track = 0;
    if (ty && ty->clientdata) {
      swig_class *sklass = (swig_class *) ty->clientdata;
      track = sklass->trackObjects;
    }
		
    if (track) {
      /* We are tracking objects for this class.  Thus we change the destructor
       * to SWIG_RubyRemoveTracking.  This allows us to
       * remove the mapping from the C++ to Ruby object
       * when the Ruby object is garbage collected.  If we don't
       * do this, then it is possible we will return a reference 
       * to a Ruby object that no longer exists thereby crashing Ruby. */
      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
    } else {    
      RDATA(obj)->dfree = 0;
    }
  }

  /* Do type-checking if type info was provided */
  if (ty) {
    if (ty->clientdata) {
      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
        if (vptr == 0) {
          /* The object has already been deleted */
          return SWIG_ObjectPreviouslyDeletedError;
        }
        *ptr = vptr;
        return SWIG_OK;
      }
    }
    if ((c = SWIG_MangleStr(obj)) == NULL) {
      return SWIG_ERROR;
    }
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) {
      return SWIG_ERROR;
    } else {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    }
  } else {
    *ptr = vptr;
  }
  
  return SWIG_OK;
}

/* Check convert */
SWIGRUNTIMEINLINE int
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
{
  char *c = SWIG_MangleStr(obj);
  if (!c) return 0;
  return SWIG_TypeCheck(c,ty) != 0;
}

SWIGRUNTIME VALUE
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r, ptr, sz);
  strcpy(r, type->name);
  return rb_str_new2(result);
}

/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
  swig_cast_info *tc;
  const char  *c;

  if (TYPE(obj) != T_STRING) goto type_error;
  c = StringValuePtr(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c, ptr, sz);
  if (ty) {
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) goto type_error;
  }
  return SWIG_OK;

 type_error:
  return SWIG_ERROR;
}

SWIGRUNTIME swig_module_info *
SWIG_Ruby_GetModule(void)
{
  VALUE pointer;
  swig_module_info *ret = 0;
  VALUE verbose = rb_gv_get("VERBOSE");

 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
  rb_gv_set("VERBOSE", Qfalse);
  
  /* first check if pointer already created */
  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
  if (pointer != Qnil) {
    Data_Get_Struct(pointer, swig_module_info, ret);
  }

  /* reinstate warnings */
  rb_gv_set("VERBOSE", verbose);
  return ret;
}

SWIGRUNTIME void 
SWIG_Ruby_SetModule(swig_module_info *pointer)
{
  /* register a new class */
  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
  /* create and store the structure pointer to a global variable */
  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
}

/* This function can be used to check whether a proc or method or similarly
   callable function has been passed.  Usually used in a %typecheck, like:

   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
        $result = SWIG_Ruby_isCallable( $input );
   }
 */
SWIGINTERN
int SWIG_Ruby_isCallable( VALUE proc )
{
  if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
    return 1;
  return 0;
}

/* This function can be used to check the arity (number of arguments)
   a proc or method can take.  Usually used in a %typecheck.
   Valid arities will be that equal to minimal or those < 0
   which indicate a variable number of parameters at the end.
 */
SWIGINTERN
int SWIG_Ruby_arity( VALUE proc, int minimal )
{
  if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
    {
      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
      int arity = NUM2INT(num);
      if ( arity < 0 && (arity+1) < -minimal ) return 1;
      if ( arity == minimal ) return 1;
      return 1;
    }
  return 0;
}


#ifdef __cplusplus
}
#endif



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

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



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

/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes that proxy
 * method calls from C++ to Ruby extensions.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_NOUEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swift
*/
#ifndef SWIG_DIRECTOR_NOUEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif

#ifdef __cplusplus

#include <string>
#include <iostream>
#include <map>

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)

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

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


  template <typename Type>
  struct GCItem_T : GCItem
  {
    GCItem_T(Type *ptr) : _ptr(ptr)
    {
    }
    
    virtual ~GCItem_T() 
    {
      delete _ptr;
    }
    
  private:
    Type *_ptr;
  };

  struct GCItem_Object : GCItem
  {
    GCItem_Object(ruby_owntype own) : _own(own)
    {
    }
    
    virtual ~GCItem_Object() 
    {
    }

    ruby_owntype get_own() const
    {
      return _own;
    }
    
  private:
    ruby_owntype _own;
  };


  template <typename Type>
  struct GCArray_T : GCItem
  {
    GCArray_T(Type *ptr) : _ptr(ptr)
    {
    }
    
    virtual ~GCArray_T() 
    {
      delete[] _ptr;
    }
    
  private:
    Type *_ptr;
  };


  /* body args */
  struct body_args {
    VALUE recv;
    ID id;
    int argc;
    VALUE *argv;
  };
  
  /* Base class for director exceptions */
  class DirectorException {
  protected:
    VALUE swig_error;
    std::string swig_msg;
  protected:
    DirectorException(VALUE error)
      : swig_error(error)
    {
    }
    
    DirectorException(VALUE error, const char* hdr, const char* msg ="") 
      : swig_error(error), swig_msg(hdr) {
      if (strlen(msg)) {
	swig_msg += " ";
	swig_msg += msg;
      }
      if (swig_msg.size()) {
	VALUE str = rb_str_new(swig_msg.data(), swig_msg.size());
	swig_error = rb_exc_new3(error, str);
      } else {
	swig_error = error;
      }
    }
  public:
    VALUE getType() const  { 
      return CLASS_OF(swig_error); 
    }
    VALUE getError() const {
      return swig_error;
    }
    const std::string& getMessage() const 
    {
      return swig_msg;
    }
    
    virtual ~DirectorException() {}
  };
  
  /* unknown exception handler  */

  class UnknownExceptionHandler 
  {
#ifdef SWIG_DIRECTOR_UEH
    static void handler() {
      try {
	throw;
      } catch (DirectorException& e) {
	std::cerr << "SWIG Director exception caught:" << std::endl
		  << e.getMessage() << std::endl;
      } catch (std::exception& e) {
	std::cerr << "std::exception caught: "<< e.what() << std::endl;
      } catch (...) {
	std::cerr << "Unknown exception caught." << std::endl;
      }      
      std::cerr << std::endl
		<< "Ruby interpreter traceback:" << std::endl;
      std::cerr << std::endl;      
      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
		<< "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
		<< std::endl
		<< "Exception is being re-thrown, program will like abort/terminate." << std::endl;
      throw;
    }
    
  public:    
    std::unexpected_handler old;
    UnknownExceptionHandler(std::unexpected_handler nh = handler)
    {
      old = std::set_unexpected(nh);
    }

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


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

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

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

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

  /* Any Ruby exception that occurs during a director method call */
  class DirectorMethodException : public Swig::DirectorException {
  public:
    DirectorMethodException(VALUE error) 
      : Swig::DirectorException(error) {
    }

    DirectorMethodException(const char* msg = "") 
      : Swig::DirectorException(rb_eRuntimeError, "SWIG director method error.", msg) {
    }
    
    static void raise(VALUE error)
    {
      throw DirectorMethodException(error);
    }    
  };

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

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

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

#ifdef  __PTHREAD__
  struct Guard
  {
    pthread_mutex_t *_mutex;
    
    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
    {
      pthread_mutex_lock(_mutex);
    }
    
    ~Guard()
    {
      pthread_mutex_unlock(_mutex);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex) 
#endif

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

  public:
    /* wrap a Ruby object, optionally taking ownership */
    Director(VALUE self) : swig_self(self), swig_disown_flag(false) {
    }

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

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

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

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

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr)  const
    {
      if (vptr) {
	SWIG_GUARD(swig_mutex_own);
	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, ruby_owntype own) const
    {
      if (vptr && own) {
	SWIG_GUARD(swig_mutex_own);
	swig_owner[vptr] = new GCItem_Object(own);
      }
    }
    
    ruby_owntype swig_release_ownership(void *vptr) const
    {
      ruby_owntype 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;
    }
  };
}

#endif /* __cplusplus */



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

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

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

#define SWIG_init    Init_quickfix
#define SWIG_name    "Quickfix"

static VALUE mQuickfix;

#define SWIG_RUBY_THREAD_BEGIN_BLOCK
#define SWIG_RUBY_THREAD_END_BLOCK


#define SWIGVERSION 0x020004 
#define SWIG_VERSION SWIGVERSION


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


#include <stdexcept>


#ifdef __cplusplus
extern "C" {
#endif

// Ruby 1.9 changed the file name of this header
#ifdef HAVE_RUBY_IO_H
#include "ruby/io.h"
#else
#include "rubyio.h"
#endif

#ifdef __cplusplus
}
#endif


#ifdef __cplusplus
extern "C" {
#endif
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
struct timeval rb_time_timeval(VALUE);
#endif
#ifdef __cplusplus
}
#endif


#include <string>


typedef int IntArray;


SWIGINTERN VALUE
SWIG_ruby_failed(void)
{
  return Qnil;
} 


/*@SWIG:/usr/local/share/swig/2.0.4/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  unsigned long *res = (unsigned long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    unsigned long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


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

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

#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


  #define SWIG_From_long   LONG2NUM 


SWIGINTERNINLINE VALUE
SWIG_From_int  (int value)
{    
  return SWIG_From_long  (value);
}


/*@SWIG:/usr/local/share/swig/2.0.4/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  long *res = (long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_long (VALUE obj, long* val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


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

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

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


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


SWIGINTERN int
SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
{
  if (TYPE(obj) == T_STRING) {
    #if defined(StringValuePtr)
    char *cstr = StringValuePtr(obj); 
    #else
    char *cstr = STR2CSTR(obj);
    #endif
    size_t size = RSTRING_LEN(obj) + 1;
    if (cptr)  {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      }
    }
    if (psize) *psize = size;
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *)vptr;
	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }  
  return SWIG_TypeError;
}


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


SWIGINTERNINLINE VALUE 
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > LONG_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
    } else {
      return rb_str_new(carray, static_cast< long >(size));
    }
  } else {
    return Qnil;
  }
}


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

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

SWIGINTERNINLINE VALUE
SWIG_From_bool  (bool value)
{
  return value ? Qtrue : Qfalse;
}

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




SWIGINTERN int
SWIG_AsCharArray(VALUE obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (VALUE 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 VALUE
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}


/*@SWIG:/usr/local/share/swig/2.0.4/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  double *res = (double *)(args[1]);
  *res = NUM2DBL(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_double (VALUE obj, double *val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
    double v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


  #define SWIG_From_double   rb_float_new 


SWIGINTERN int
SWIG_AsVal_bool (VALUE obj, bool *val)
{
  if (obj == Qtrue) {
    if (val) *val = true;
    return SWIG_OK;
  } else if (obj == Qfalse) {
    if (val) *val = false;
    return SWIG_OK;
  } else {
    int res = 0;
    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
      if (val) *val = res ? true : false;
      return SWIG_OK;
    }
  }  
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (VALUE 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 VALUE 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}

SWIGINTERN std::string FIX_SessionID___str__(FIX::SessionID *self){
    return self->toString();
  }
/* ---------------------------------------------------
 * C++ director class helpers
 * --------------------------------------------------- */

static int Application_onCreate_call_depth = 0;
VALUE Application_onCreate_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_onCreate_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_onCreate_call_depth--;
  return result;
}

VALUE Application_onCreate_rescue(VALUE args, VALUE error) {
  Application_onCreate_call_depth--;
  if (Application_onCreate_call_depth == 0) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
  }
  rb_exc_raise(error);
}

static int Application_onLogon_call_depth = 0;
VALUE Application_onLogon_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_onLogon_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_onLogon_call_depth--;
  return result;
}

VALUE Application_onLogon_rescue(VALUE args, VALUE error) {
  Application_onLogon_call_depth--;
  if (Application_onLogon_call_depth == 0) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
  }
  rb_exc_raise(error);
}

static int Application_onLogout_call_depth = 0;
VALUE Application_onLogout_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_onLogout_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_onLogout_call_depth--;
  return result;
}

VALUE Application_onLogout_rescue(VALUE args, VALUE error) {
  Application_onLogout_call_depth--;
  if (Application_onLogout_call_depth == 0) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
  }
  rb_exc_raise(error);
}

static int Application_toAdmin_call_depth = 0;
VALUE Application_toAdmin_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_toAdmin_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_toAdmin_call_depth--;
  return result;
}

VALUE Application_toAdmin_rescue(VALUE args, VALUE error) {
  Application_toAdmin_call_depth--;
  if (Application_toAdmin_call_depth == 0) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
  }
  rb_exc_raise(error);
}

static int Application_toApp_call_depth = 0;
VALUE Application_toApp_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_toApp_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_toApp_call_depth--;
  return result;
}

VALUE Application_toApp_rescue(VALUE args, VALUE error) {
  Application_toApp_call_depth--;
  if (Application_toApp_call_depth == 0) {
    if( error != 0 ) {
      void* result;
      
      Application_toApp_call_depth--;
      
      if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__DoNotSend, 0 ) != -1 ) {
        throw *((FIX::DoNotSend*)result);
      } else {
        VALUE message = rb_obj_as_string( error );
        printf( "%s\n", RSTRING(message)->ptr );
        exit(1);
      }
    }
    
  }
  rb_exc_raise(error);
}

static int Application_fromAdmin_call_depth = 0;
VALUE Application_fromAdmin_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_fromAdmin_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_fromAdmin_call_depth--;
  return result;
}

VALUE Application_fromAdmin_rescue(VALUE args, VALUE error) {
  Application_fromAdmin_call_depth--;
  if (Application_fromAdmin_call_depth == 0) {
    if( error != 0 ) {
      void* result;
      
      Application_fromAdmin_call_depth--;
      
      if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__FieldNotFound, 0 ) != -1 ) {
        throw *((FIX::FieldNotFound*)result);
      } else if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__IncorrectDataFormat, 0 ) != -1 ) {
        throw *((FIX::IncorrectDataFormat*)result);
      } else if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__IncorrectTagValue, 0 ) != -1 ) {
        throw *((FIX::IncorrectTagValue*)result);
      } else if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__RejectLogon, 0 ) != -1 ) {
        throw *((FIX::RejectLogon*)result);
      } else {
        VALUE message = rb_obj_as_string( error );
        printf( "%s\n", RSTRING(message)->ptr );
        exit(1);
      }
    }
    
  }
  rb_exc_raise(error);
}

static int Application_fromApp_call_depth = 0;
VALUE Application_fromApp_body(VALUE data) {
  Swig::body_args * args = reinterpret_cast<Swig::body_args *>(data) ;
  VALUE result = Qnil ;
  
  Application_fromApp_call_depth++;
  result = rb_funcall2(args->recv, args->id, args->argc, args->argv);
  Application_fromApp_call_depth--;
  return result;
}

VALUE Application_fromApp_rescue(VALUE args, VALUE error) {
  Application_fromApp_call_depth--;
  if (Application_fromApp_call_depth == 0) {
    if( error != 0 ) {
      void* result;
      
      Application_fromApp_call_depth--;
      
      if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__FieldNotFound, 0 ) != -1 ) {
        throw *((FIX::FieldNotFound*)result);
      } else if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__IncorrectDataFormat, 0 ) != -1 ) {
        throw *((FIX::IncorrectDataFormat*)result);
      } else if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__IncorrectTagValue, 0 ) != -1 ) {
        throw *((FIX::IncorrectTagValue*)result);
      } else if( SWIG_ConvertPtr(error, &result, SWIGTYPE_p_FIX__UnsupportedMessageType, 0 ) != -1 ) {
        throw *((FIX::UnsupportedMessageType*)result);
      } else {
        VALUE message = rb_obj_as_string( error );
        printf( "%s\n", RSTRING(message)->ptr );
        exit(1);
      }
    }
    
  }
  rb_exc_raise(error);
}



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

#include "QuickfixRuby.h"

SwigDirector_Application::SwigDirector_Application(VALUE self): FIX::Application(), Swig::Director(self) {
  
}



SwigDirector_Application::~SwigDirector_Application() {
}

void SwigDirector_Application::onCreate(FIX::SessionID const &arg0) {
  VALUE obj0 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("onCreate");
  args.argc = 1;
  args.argv = new VALUE[1];
  args.argv[0] = obj0;
  result = rb_protect(PROTECTFUNC(Application_onCreate_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_onCreate_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


void SwigDirector_Application::onLogon(FIX::SessionID const &arg0) {
  VALUE obj0 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("onLogon");
  args.argc = 1;
  args.argv = new VALUE[1];
  args.argv[0] = obj0;
  result = rb_protect(PROTECTFUNC(Application_onLogon_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_onLogon_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


void SwigDirector_Application::onLogout(FIX::SessionID const &arg0) {
  VALUE obj0 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("onLogout");
  args.argc = 1;
  args.argv = new VALUE[1];
  args.argv[0] = obj0;
  result = rb_protect(PROTECTFUNC(Application_onLogout_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_onLogout_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


void SwigDirector_Application::toAdmin(FIX::Message &arg0, FIX::SessionID const &arg1) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("toAdmin");
  args.argc = 2;
  args.argv = new VALUE[2];
  args.argv[0] = obj0;
  args.argv[1] = obj1;
  result = rb_protect(PROTECTFUNC(Application_toAdmin_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_toAdmin_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


void SwigDirector_Application::toApp(FIX::Message &arg0, FIX::SessionID const &arg1) throw(FIX::DoNotSend) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("toApp");
  args.argc = 2;
  args.argv = new VALUE[2];
  args.argv[0] = obj0;
  args.argv[1] = obj1;
  result = rb_protect(PROTECTFUNC(Application_toApp_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_toApp_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


void SwigDirector_Application::fromAdmin(FIX::Message const &arg0, FIX::SessionID const &arg1) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("fromAdmin");
  args.argc = 2;
  args.argv = new VALUE[2];
  args.argv[0] = obj0;
  args.argv[1] = obj1;
  result = rb_protect(PROTECTFUNC(Application_fromAdmin_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_fromAdmin_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


void SwigDirector_Application::fromApp(FIX::Message const &arg0, FIX::SessionID const &arg1) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE result;
  Swig::body_args args ;
  int status ;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
  args.recv = swig_get_self();
  args.id = rb_intern("fromApp");
  args.argc = 2;
  args.argv = new VALUE[2];
  args.argv[0] = obj0;
  args.argv[1] = obj1;
  result = rb_protect(PROTECTFUNC(Application_fromApp_body), reinterpret_cast<VALUE>(&args), &status);
  if (status) {
    VALUE lastErr = rb_gv_get("$!");
    Application_fromApp_rescue(reinterpret_cast<VALUE>(&args), lastErr);
  }
  delete [] args.argv;
}


swig_class SwigClassIntArray;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IntArray_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IntArray_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_IntArray);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IntArray(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IntArray";
  IntArray *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","IntArray", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  result = (IntArray *)new_IntArray(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_IntArray(IntArray *self){
    delete[] self;
  }
SWIGINTERN void
free_IntArray(IntArray *arg1) {
    delete_IntArray(arg1);
}


/*
  Document-method: Quickfix::IntArray.[]

  call-seq:
    [](index) -> int

Element accessor/slicing.
*/
SWIGINTERN VALUE
_wrap_IntArray___getitem__(int argc, VALUE *argv, VALUE self) {
  IntArray *arg1 = (IntArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "IntArray *","__getitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","__getitem__", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int)IntArray___getitem__(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::IntArray.[]=

  call-seq:
    []=(index, value)

Element setter/slicing.
*/
SWIGINTERN VALUE
_wrap_IntArray___setitem__(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "IntArray *","__setitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","__setitem__", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","__setitem__", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  IntArray___setitem__(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntArray_cast(int argc, VALUE *argv, VALUE self) {
  IntArray *arg1 = (IntArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "IntArray *","cast", 1, self )); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  result = (int *)IntArray_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntArray_frompointer(int argc, VALUE *argv, VALUE self) {
  int *arg1 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  IntArray *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int *","IntArray_frompointer", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  result = (IntArray *)IntArray_frompointer(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntArray, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassException;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Exception_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Exception_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Exception);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Exception(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::Exception";
  FIX::Exception *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Exception", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Exception", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::Exception", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Exception", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::Exception *)new FIX::Exception((std::string const &)*arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_FIX_Exception(FIX::Exception *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Exception_type_set(int argc, VALUE *argv, VALUE self) {
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Exception *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","type", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","type", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->type = *arg2;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_type_get(int argc, VALUE *argv, VALUE self) {
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Exception *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  result = (std::string *) & ((arg1)->type);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_detail_set(int argc, VALUE *argv, VALUE self) {
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Exception *","detail", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","detail", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","detail", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->detail = *arg2;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_detail_get(int argc, VALUE *argv, VALUE self) {
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Exception *","detail", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  result = (std::string *) & ((arg1)->detail);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception___str__(int argc, VALUE *argv, VALUE self) {
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Exception *","__str__", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  result = FIX_Exception___str__(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDataDictionaryNotFound;

SWIGINTERN VALUE
_wrap_new_DataDictionaryNotFound__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionaryNotFound";
  FIX::DataDictionaryNotFound *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::DataDictionaryNotFound", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::DataDictionaryNotFound", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::DataDictionaryNotFound", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::DataDictionaryNotFound", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::DataDictionaryNotFound *)new FIX::DataDictionaryNotFound((std::string const &)*arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DataDictionaryNotFound_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DataDictionaryNotFound_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DataDictionaryNotFound);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DataDictionaryNotFound__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionaryNotFound";
  FIX::DataDictionaryNotFound *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::DataDictionaryNotFound", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::DataDictionaryNotFound", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::DataDictionaryNotFound *)new FIX::DataDictionaryNotFound((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DataDictionaryNotFound(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionaryNotFound__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DataDictionaryNotFound__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "DataDictionaryNotFound.new", 
    "    DataDictionaryNotFound.new(std::string const &v, std::string const &what)\n"
    "    DataDictionaryNotFound.new(std::string const &v)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DataDictionaryNotFound(FIX::DataDictionaryNotFound *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DataDictionaryNotFound_version_set(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionaryNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionaryNotFound *","version", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionaryNotFound * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","version", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","version", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->version = *arg2;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionaryNotFound_version_get(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionaryNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionaryNotFound *","version", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionaryNotFound * >(argp1);
  result = (std::string *) & ((arg1)->version);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassFieldNotFound;

SWIGINTERN VALUE
_wrap_new_FieldNotFound__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FieldNotFound";
  FIX::FieldNotFound *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::FieldNotFound", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::FieldNotFound", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FieldNotFound", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::FieldNotFound *)new FIX::FieldNotFound(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FieldNotFound__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldNotFound";
  FIX::FieldNotFound *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::FieldNotFound", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::FieldNotFound *)new FIX::FieldNotFound(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FieldNotFound_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FieldNotFound_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FieldNotFound);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FieldNotFound__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FieldNotFound";
  FIX::FieldNotFound *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FieldNotFound *)new FIX::FieldNotFound();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FieldNotFound(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FieldNotFound__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FieldNotFound__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FieldNotFound__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "FieldNotFound.new", 
    "    FieldNotFound.new(int f, std::string const &what)\n"
    "    FieldNotFound.new(int f)\n"
    "    FieldNotFound.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldNotFound_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldNotFound *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldNotFound * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldNotFound_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldNotFound *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldNotFound * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_FieldNotFound(FIX::FieldNotFound *arg1) {
    delete arg1;
}

swig_class SwigClassFieldConvertError;

SWIGINTERN VALUE
_wrap_new_FieldConvertError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FieldConvertError";
  FIX::FieldConvertError *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FieldConvertError", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FieldConvertError", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::FieldConvertError *)new FIX::FieldConvertError((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FieldConvertError_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FieldConvertError_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FieldConvertError);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FieldConvertError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FieldConvertError";
  FIX::FieldConvertError *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FieldConvertError *)new FIX::FieldConvertError();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FieldConvertError(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FieldConvertError__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldConvertError__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FieldConvertError.new", 
    "    FieldConvertError.new(std::string const &what)\n"
    "    FieldConvertError.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FieldConvertError(FIX::FieldConvertError *arg1) {
    delete arg1;
}

swig_class SwigClassMessageParseError;

SWIGINTERN VALUE
_wrap_new_MessageParseError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::MessageParseError";
  FIX::MessageParseError *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::MessageParseError", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::MessageParseError", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::MessageParseError *)new FIX::MessageParseError((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MessageParseError_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MessageParseError_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MessageParseError);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MessageParseError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MessageParseError";
  FIX::MessageParseError *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MessageParseError *)new FIX::MessageParseError();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MessageParseError(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MessageParseError__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MessageParseError__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MessageParseError.new", 
    "    MessageParseError.new(std::string const &what)\n"
    "    MessageParseError.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageParseError(FIX::MessageParseError *arg1) {
    delete arg1;
}

swig_class SwigClassInvalidMessage;

SWIGINTERN VALUE
_wrap_new_InvalidMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessage";
  FIX::InvalidMessage *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::InvalidMessage", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::InvalidMessage", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::InvalidMessage *)new FIX::InvalidMessage((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InvalidMessage_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InvalidMessage_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InvalidMessage);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InvalidMessage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessage";
  FIX::InvalidMessage *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InvalidMessage *)new FIX::InvalidMessage();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InvalidMessage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InvalidMessage__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidMessage__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InvalidMessage.new", 
    "    InvalidMessage.new(std::string const &what)\n"
    "    InvalidMessage.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InvalidMessage(FIX::InvalidMessage *arg1) {
    delete arg1;
}

swig_class SwigClassConfigError;

SWIGINTERN VALUE
_wrap_new_ConfigError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::ConfigError";
  FIX::ConfigError *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::ConfigError", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::ConfigError", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::ConfigError *)new FIX::ConfigError((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfigError_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfigError_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfigError);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfigError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfigError";
  FIX::ConfigError *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfigError *)new FIX::ConfigError();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfigError(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfigError__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfigError__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfigError.new", 
    "    ConfigError.new(std::string const &what)\n"
    "    ConfigError.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfigError(FIX::ConfigError *arg1) {
    delete arg1;
}

swig_class SwigClassRuntimeError;

SWIGINTERN VALUE
_wrap_new_RuntimeError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RuntimeError";
  FIX::RuntimeError *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::RuntimeError", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::RuntimeError", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::RuntimeError *)new FIX::RuntimeError((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RuntimeError_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RuntimeError_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RuntimeError);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RuntimeError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RuntimeError";
  FIX::RuntimeError *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RuntimeError *)new FIX::RuntimeError();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RuntimeError(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RuntimeError__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RuntimeError__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RuntimeError.new", 
    "    RuntimeError.new(std::string const &what)\n"
    "    RuntimeError.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RuntimeError(FIX::RuntimeError *arg1) {
    delete arg1;
}

swig_class SwigClassInvalidTagNumber;

SWIGINTERN VALUE
_wrap_new_InvalidTagNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidTagNumber";
  FIX::InvalidTagNumber *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::InvalidTagNumber", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::InvalidTagNumber", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::InvalidTagNumber", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_InvalidTagNumber__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidTagNumber";
  FIX::InvalidTagNumber *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::InvalidTagNumber", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InvalidTagNumber_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InvalidTagNumber_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InvalidTagNumber);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InvalidTagNumber__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InvalidTagNumber";
  FIX::InvalidTagNumber *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InvalidTagNumber(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InvalidTagNumber__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InvalidTagNumber__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvalidTagNumber__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "InvalidTagNumber.new", 
    "    InvalidTagNumber.new(int f, std::string const &what)\n"
    "    InvalidTagNumber.new(int f)\n"
    "    InvalidTagNumber.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InvalidTagNumber_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__InvalidTagNumber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::InvalidTagNumber *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::InvalidTagNumber * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InvalidTagNumber_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__InvalidTagNumber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::InvalidTagNumber *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::InvalidTagNumber * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_InvalidTagNumber(FIX::InvalidTagNumber *arg1) {
    delete arg1;
}

swig_class SwigClassRequiredTagMissing;

SWIGINTERN VALUE
_wrap_new_RequiredTagMissing__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RequiredTagMissing";
  FIX::RequiredTagMissing *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::RequiredTagMissing", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::RequiredTagMissing", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::RequiredTagMissing", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RequiredTagMissing__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RequiredTagMissing";
  FIX::RequiredTagMissing *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::RequiredTagMissing", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RequiredTagMissing_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RequiredTagMissing_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RequiredTagMissing);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RequiredTagMissing__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RequiredTagMissing";
  FIX::RequiredTagMissing *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RequiredTagMissing(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RequiredTagMissing__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RequiredTagMissing__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RequiredTagMissing__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RequiredTagMissing.new", 
    "    RequiredTagMissing.new(int f, std::string const &what)\n"
    "    RequiredTagMissing.new(int f)\n"
    "    RequiredTagMissing.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RequiredTagMissing_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__RequiredTagMissing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::RequiredTagMissing *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::RequiredTagMissing * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RequiredTagMissing_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__RequiredTagMissing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::RequiredTagMissing *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::RequiredTagMissing * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_RequiredTagMissing(FIX::RequiredTagMissing *arg1) {
    delete arg1;
}

swig_class SwigClassTagNotDefinedForMessage;

SWIGINTERN VALUE
_wrap_new_TagNotDefinedForMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::TagNotDefinedForMessage";
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::TagNotDefinedForMessage", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::TagNotDefinedForMessage", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::TagNotDefinedForMessage", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TagNotDefinedForMessage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TagNotDefinedForMessage";
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::TagNotDefinedForMessage", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TagNotDefinedForMessage_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TagNotDefinedForMessage_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TagNotDefinedForMessage);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TagNotDefinedForMessage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TagNotDefinedForMessage";
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TagNotDefinedForMessage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TagNotDefinedForMessage__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TagNotDefinedForMessage__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TagNotDefinedForMessage__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TagNotDefinedForMessage.new", 
    "    TagNotDefinedForMessage.new(int f, std::string const &what)\n"
    "    TagNotDefinedForMessage.new(int f)\n"
    "    TagNotDefinedForMessage.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagNotDefinedForMessage_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__TagNotDefinedForMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TagNotDefinedForMessage *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::TagNotDefinedForMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagNotDefinedForMessage_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__TagNotDefinedForMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TagNotDefinedForMessage *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::TagNotDefinedForMessage * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_TagNotDefinedForMessage(FIX::TagNotDefinedForMessage *arg1) {
    delete arg1;
}

swig_class SwigClassNoTagValue;

SWIGINTERN VALUE
_wrap_new_NoTagValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::NoTagValue";
  FIX::NoTagValue *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::NoTagValue", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::NoTagValue", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::NoTagValue", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::NoTagValue *)new FIX::NoTagValue(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_NoTagValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTagValue";
  FIX::NoTagValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::NoTagValue", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::NoTagValue *)new FIX::NoTagValue(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTagValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTagValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTagValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTagValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTagValue";
  FIX::NoTagValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTagValue *)new FIX::NoTagValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTagValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTagValue__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_NoTagValue__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NoTagValue__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "NoTagValue.new", 
    "    NoTagValue.new(int f, std::string const &what)\n"
    "    NoTagValue.new(int f)\n"
    "    NoTagValue.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NoTagValue_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NoTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NoTagValue *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NoTagValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NoTagValue_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NoTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NoTagValue *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NoTagValue * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTagValue(FIX::NoTagValue *arg1) {
    delete arg1;
}

swig_class SwigClassIncorrectTagValue;

SWIGINTERN VALUE
_wrap_new_IncorrectTagValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectTagValue";
  FIX::IncorrectTagValue *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::IncorrectTagValue", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::IncorrectTagValue", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::IncorrectTagValue", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_IncorrectTagValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectTagValue";
  FIX::IncorrectTagValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::IncorrectTagValue", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IncorrectTagValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IncorrectTagValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IncorrectTagValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IncorrectTagValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IncorrectTagValue";
  FIX::IncorrectTagValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IncorrectTagValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IncorrectTagValue__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IncorrectTagValue__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IncorrectTagValue__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "IncorrectTagValue.new", 
    "    IncorrectTagValue.new(int f, std::string const &what)\n"
    "    IncorrectTagValue.new(int f)\n"
    "    IncorrectTagValue.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IncorrectTagValue_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__IncorrectTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::IncorrectTagValue *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectTagValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IncorrectTagValue_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__IncorrectTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::IncorrectTagValue *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectTagValue * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_IncorrectTagValue(FIX::IncorrectTagValue *arg1) {
    delete arg1;
}

swig_class SwigClassIncorrectDataFormat;

SWIGINTERN VALUE
_wrap_new_IncorrectDataFormat__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectDataFormat";
  FIX::IncorrectDataFormat *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::IncorrectDataFormat", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::IncorrectDataFormat", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::IncorrectDataFormat", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_IncorrectDataFormat__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectDataFormat";
  FIX::IncorrectDataFormat *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::IncorrectDataFormat", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IncorrectDataFormat_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IncorrectDataFormat_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IncorrectDataFormat);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IncorrectDataFormat__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IncorrectDataFormat";
  FIX::IncorrectDataFormat *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IncorrectDataFormat(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IncorrectDataFormat__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IncorrectDataFormat__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IncorrectDataFormat__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "IncorrectDataFormat.new", 
    "    IncorrectDataFormat.new(int f, std::string const &what)\n"
    "    IncorrectDataFormat.new(int f)\n"
    "    IncorrectDataFormat.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IncorrectDataFormat_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__IncorrectDataFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::IncorrectDataFormat *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectDataFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IncorrectDataFormat_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__IncorrectDataFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::IncorrectDataFormat *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectDataFormat * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_IncorrectDataFormat(FIX::IncorrectDataFormat *arg1) {
    delete arg1;
}

swig_class SwigClassIncorrectMessageStructure;

SWIGINTERN VALUE
_wrap_new_IncorrectMessageStructure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectMessageStructure";
  FIX::IncorrectMessageStructure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::IncorrectMessageStructure", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::IncorrectMessageStructure", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::IncorrectMessageStructure *)new FIX::IncorrectMessageStructure((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IncorrectMessageStructure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IncorrectMessageStructure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IncorrectMessageStructure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IncorrectMessageStructure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IncorrectMessageStructure";
  FIX::IncorrectMessageStructure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IncorrectMessageStructure *)new FIX::IncorrectMessageStructure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IncorrectMessageStructure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IncorrectMessageStructure__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IncorrectMessageStructure__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IncorrectMessageStructure.new", 
    "    IncorrectMessageStructure.new(std::string const &what)\n"
    "    IncorrectMessageStructure.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IncorrectMessageStructure(FIX::IncorrectMessageStructure *arg1) {
    delete arg1;
}

swig_class SwigClassDuplicateFieldNumber;

SWIGINTERN VALUE
_wrap_new_DuplicateFieldNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DuplicateFieldNumber";
  FIX::DuplicateFieldNumber *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::DuplicateFieldNumber", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::DuplicateFieldNumber", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::DuplicateFieldNumber *)new FIX::DuplicateFieldNumber((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DuplicateFieldNumber_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DuplicateFieldNumber_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DuplicateFieldNumber);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DuplicateFieldNumber__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DuplicateFieldNumber";
  FIX::DuplicateFieldNumber *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DuplicateFieldNumber *)new FIX::DuplicateFieldNumber();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DuplicateFieldNumber(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DuplicateFieldNumber__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DuplicateFieldNumber__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DuplicateFieldNumber.new", 
    "    DuplicateFieldNumber.new(std::string const &what)\n"
    "    DuplicateFieldNumber.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DuplicateFieldNumber(FIX::DuplicateFieldNumber *arg1) {
    delete arg1;
}

swig_class SwigClassInvalidMessageType;

SWIGINTERN VALUE
_wrap_new_InvalidMessageType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessageType";
  FIX::InvalidMessageType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::InvalidMessageType", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::InvalidMessageType", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::InvalidMessageType *)new FIX::InvalidMessageType((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InvalidMessageType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InvalidMessageType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InvalidMessageType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InvalidMessageType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessageType";
  FIX::InvalidMessageType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InvalidMessageType *)new FIX::InvalidMessageType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InvalidMessageType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InvalidMessageType__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvalidMessageType__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InvalidMessageType.new", 
    "    InvalidMessageType.new(std::string const &what)\n"
    "    InvalidMessageType.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InvalidMessageType(FIX::InvalidMessageType *arg1) {
    delete arg1;
}

swig_class SwigClassUnsupportedMessageType;

SWIGINTERN VALUE
_wrap_new_UnsupportedMessageType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedMessageType";
  FIX::UnsupportedMessageType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::UnsupportedMessageType", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::UnsupportedMessageType", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::UnsupportedMessageType *)new FIX::UnsupportedMessageType((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnsupportedMessageType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnsupportedMessageType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnsupportedMessageType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnsupportedMessageType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedMessageType";
  FIX::UnsupportedMessageType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnsupportedMessageType *)new FIX::UnsupportedMessageType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnsupportedMessageType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnsupportedMessageType__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsupportedMessageType__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnsupportedMessageType.new", 
    "    UnsupportedMessageType.new(std::string const &what)\n"
    "    UnsupportedMessageType.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnsupportedMessageType(FIX::UnsupportedMessageType *arg1) {
    delete arg1;
}

swig_class SwigClassUnsupportedVersion;

SWIGINTERN VALUE
_wrap_new_UnsupportedVersion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedVersion";
  FIX::UnsupportedVersion *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::UnsupportedVersion", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::UnsupportedVersion", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::UnsupportedVersion *)new FIX::UnsupportedVersion((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnsupportedVersion_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnsupportedVersion_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnsupportedVersion);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnsupportedVersion__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedVersion";
  FIX::UnsupportedVersion *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnsupportedVersion *)new FIX::UnsupportedVersion();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnsupportedVersion(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnsupportedVersion__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsupportedVersion__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnsupportedVersion.new", 
    "    UnsupportedVersion.new(std::string const &what)\n"
    "    UnsupportedVersion.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnsupportedVersion(FIX::UnsupportedVersion *arg1) {
    delete arg1;
}

swig_class SwigClassTagOutOfOrder;

SWIGINTERN VALUE
_wrap_new_TagOutOfOrder__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::TagOutOfOrder";
  FIX::TagOutOfOrder *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::TagOutOfOrder", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::TagOutOfOrder", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::TagOutOfOrder", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TagOutOfOrder__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TagOutOfOrder";
  FIX::TagOutOfOrder *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::TagOutOfOrder", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TagOutOfOrder_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TagOutOfOrder_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TagOutOfOrder);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TagOutOfOrder__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TagOutOfOrder";
  FIX::TagOutOfOrder *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TagOutOfOrder(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TagOutOfOrder__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TagOutOfOrder__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TagOutOfOrder__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TagOutOfOrder.new", 
    "    TagOutOfOrder.new(int f, std::string const &what)\n"
    "    TagOutOfOrder.new(int f)\n"
    "    TagOutOfOrder.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagOutOfOrder_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__TagOutOfOrder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TagOutOfOrder *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::TagOutOfOrder * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagOutOfOrder_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__TagOutOfOrder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TagOutOfOrder *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::TagOutOfOrder * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_TagOutOfOrder(FIX::TagOutOfOrder *arg1) {
    delete arg1;
}

swig_class SwigClassRepeatedTag;

SWIGINTERN VALUE
_wrap_new_RepeatedTag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatedTag";
  FIX::RepeatedTag *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::RepeatedTag", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::RepeatedTag", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::RepeatedTag", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::RepeatedTag *)new FIX::RepeatedTag(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RepeatedTag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatedTag";
  FIX::RepeatedTag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::RepeatedTag", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::RepeatedTag *)new FIX::RepeatedTag(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RepeatedTag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RepeatedTag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RepeatedTag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RepeatedTag__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RepeatedTag";
  FIX::RepeatedTag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RepeatedTag *)new FIX::RepeatedTag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RepeatedTag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RepeatedTag__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RepeatedTag__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RepeatedTag__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RepeatedTag.new", 
    "    RepeatedTag.new(int f, std::string const &what)\n"
    "    RepeatedTag.new(int f)\n"
    "    RepeatedTag.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RepeatedTag_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__RepeatedTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::RepeatedTag *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::RepeatedTag * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RepeatedTag_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__RepeatedTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::RepeatedTag *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::RepeatedTag * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_RepeatedTag(FIX::RepeatedTag *arg1) {
    delete arg1;
}

swig_class SwigClassRepeatingGroupCountMismatch;

SWIGINTERN VALUE
_wrap_new_RepeatingGroupCountMismatch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatingGroupCountMismatch";
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::RepeatingGroupCountMismatch", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::RepeatingGroupCountMismatch", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::RepeatingGroupCountMismatch", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RepeatingGroupCountMismatch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatingGroupCountMismatch";
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::RepeatingGroupCountMismatch", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RepeatingGroupCountMismatch_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RepeatingGroupCountMismatch_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RepeatingGroupCountMismatch);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RepeatingGroupCountMismatch__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RepeatingGroupCountMismatch";
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RepeatingGroupCountMismatch(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RepeatingGroupCountMismatch__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RepeatingGroupCountMismatch__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RepeatingGroupCountMismatch__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RepeatingGroupCountMismatch.new", 
    "    RepeatingGroupCountMismatch.new(int f, std::string const &what)\n"
    "    RepeatingGroupCountMismatch.new(int f)\n"
    "    RepeatingGroupCountMismatch.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RepeatingGroupCountMismatch_field_set(int argc, VALUE *argv, VALUE self) {
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::RepeatingGroupCountMismatch *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::RepeatingGroupCountMismatch * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","field", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->field = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RepeatingGroupCountMismatch_field_get(int argc, VALUE *argv, VALUE self) {
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::RepeatingGroupCountMismatch *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::RepeatingGroupCountMismatch * >(argp1);
  result = (int) ((arg1)->field);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_RepeatingGroupCountMismatch(FIX::RepeatingGroupCountMismatch *arg1) {
    delete arg1;
}

swig_class SwigClassDoNotSend;

SWIGINTERN VALUE
_wrap_new_DoNotSend__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DoNotSend";
  FIX::DoNotSend *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::DoNotSend", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::DoNotSend", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::DoNotSend *)new FIX::DoNotSend((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DoNotSend_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DoNotSend_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DoNotSend);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DoNotSend__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DoNotSend";
  FIX::DoNotSend *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DoNotSend *)new FIX::DoNotSend();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DoNotSend(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DoNotSend__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DoNotSend__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DoNotSend.new", 
    "    DoNotSend.new(std::string const &what)\n"
    "    DoNotSend.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DoNotSend(FIX::DoNotSend *arg1) {
    delete arg1;
}

swig_class SwigClassRejectLogon;

SWIGINTERN VALUE
_wrap_new_RejectLogon__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RejectLogon";
  FIX::RejectLogon *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::RejectLogon", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::RejectLogon", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::RejectLogon *)new FIX::RejectLogon((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RejectLogon_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RejectLogon_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RejectLogon);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RejectLogon__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RejectLogon";
  FIX::RejectLogon *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RejectLogon *)new FIX::RejectLogon();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RejectLogon(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RejectLogon__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RejectLogon__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RejectLogon.new", 
    "    RejectLogon.new(std::string const &what)\n"
    "    RejectLogon.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RejectLogon(FIX::RejectLogon *arg1) {
    delete arg1;
}

swig_class SwigClassSessionNotFound;

SWIGINTERN VALUE
_wrap_new_SessionNotFound__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionNotFound";
  FIX::SessionNotFound *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionNotFound", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionNotFound", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::SessionNotFound *)new FIX::SessionNotFound((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SessionNotFound_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SessionNotFound_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SessionNotFound);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SessionNotFound__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SessionNotFound";
  FIX::SessionNotFound *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SessionNotFound *)new FIX::SessionNotFound();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SessionNotFound(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SessionNotFound__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionNotFound__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SessionNotFound.new", 
    "    SessionNotFound.new(std::string const &what)\n"
    "    SessionNotFound.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionNotFound(FIX::SessionNotFound *arg1) {
    delete arg1;
}

swig_class SwigClassIOException;

SWIGINTERN VALUE
_wrap_new_IOException__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IOException";
  FIX::IOException *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::IOException", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::IOException", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::IOException *)new FIX::IOException((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOException_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOException_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOException);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOException__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOException";
  FIX::IOException *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOException *)new FIX::IOException();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOException(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOException__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOException__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOException.new", 
    "    IOException.new(std::string const &what)\n"
    "    IOException.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOException(FIX::IOException *arg1) {
    delete arg1;
}

swig_class SwigClassSocketException;

SWIGINTERN VALUE
_wrap_new_SocketException__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SocketException";
  FIX::SocketException *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SocketException *)new FIX::SocketException();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SocketException_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SocketException_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SocketException);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SocketException__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketException";
  FIX::SocketException *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SocketException", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SocketException", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::SocketException *)new FIX::SocketException((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SocketException(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SocketException__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketException__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SocketException.new", 
    "    SocketException.new()\n"
    "    SocketException.new(std::string const &what)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SocketException_errorToWhat(int argc, VALUE *argv, VALUE self) {
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SocketException *","errorToWhat", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  result = (arg1)->errorToWhat();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SocketException_error_set(int argc, VALUE *argv, VALUE self) {
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SocketException *","error", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","error", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->error = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SocketException_error_get(int argc, VALUE *argv, VALUE self) {
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SocketException *","error", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  result = (int) ((arg1)->error);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketException(FIX::SocketException *arg1) {
    delete arg1;
}

swig_class SwigClassSocketSendFailed;

SWIGINTERN VALUE
_wrap_new_SocketSendFailed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SocketSendFailed";
  FIX::SocketSendFailed *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SocketSendFailed *)new FIX::SocketSendFailed();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SocketSendFailed_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SocketSendFailed_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SocketSendFailed);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SocketSendFailed__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketSendFailed";
  FIX::SocketSendFailed *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SocketSendFailed", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SocketSendFailed", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::SocketSendFailed *)new FIX::SocketSendFailed((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SocketSendFailed(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SocketSendFailed__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketSendFailed__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SocketSendFailed.new", 
    "    SocketSendFailed.new()\n"
    "    SocketSendFailed.new(std::string const &what)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketSendFailed(FIX::SocketSendFailed *arg1) {
    delete arg1;
}

swig_class SwigClassSocketRecvFailed;

SWIGINTERN VALUE
_wrap_new_SocketRecvFailed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketRecvFailed";
  FIX::SocketRecvFailed *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::SocketRecvFailed", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::SocketRecvFailed *)new FIX::SocketRecvFailed(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SocketRecvFailed_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SocketRecvFailed_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SocketRecvFailed);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SocketRecvFailed__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketRecvFailed";
  FIX::SocketRecvFailed *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SocketRecvFailed", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SocketRecvFailed", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::SocketRecvFailed *)new FIX::SocketRecvFailed((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SocketRecvFailed(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SocketRecvFailed__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketRecvFailed__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SocketRecvFailed.new", 
    "    SocketRecvFailed.new(int size)\n"
    "    SocketRecvFailed.new(std::string const &what)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketRecvFailed(FIX::SocketRecvFailed *arg1) {
    delete arg1;
}

swig_class SwigClassSocketCloseFailed;

SWIGINTERN VALUE
_wrap_new_SocketCloseFailed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SocketCloseFailed";
  FIX::SocketCloseFailed *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SocketCloseFailed *)new FIX::SocketCloseFailed();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SocketCloseFailed_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SocketCloseFailed_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SocketCloseFailed);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SocketCloseFailed__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketCloseFailed";
  FIX::SocketCloseFailed *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SocketCloseFailed", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SocketCloseFailed", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::SocketCloseFailed *)new FIX::SocketCloseFailed((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SocketCloseFailed(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SocketCloseFailed__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SocketCloseFailed__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SocketCloseFailed.new", 
    "    SocketCloseFailed.new()\n"
    "    SocketCloseFailed.new(std::string const &what)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketCloseFailed(FIX::SocketCloseFailed *arg1) {
    delete arg1;
}

swig_class SwigClassFieldBase;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FieldBase_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FieldBase_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FieldBase);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FieldBase(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FieldBase";
  FIX::FieldBase *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::FieldBase", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::FieldBase", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FieldBase", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::FieldBase *)new FIX::FieldBase(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_FIX_FieldBase(FIX::FieldBase *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FieldBase_setField(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase *","setField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setField(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_setString(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase *","setString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setString((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_getField(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const *","getField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (int)((FIX::FieldBase const *)arg1)->getField();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_getString(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const *","getString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (std::string *) &((FIX::FieldBase const *)arg1)->getString();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_getFixString(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const *","getFixString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (std::string *) &((FIX::FieldBase const *)arg1)->getFixString();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_getLength(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const *","getLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (int)((FIX::FieldBase const *)arg1)->getLength();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_getTotal(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const *","getTotal", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (int)((FIX::FieldBase const *)arg1)->getTotal();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::FieldBase.<

  call-seq:
    <(field) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_FieldBase___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::FieldBase const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  result = (bool)((FIX::FieldBase const *)arg1)->operator <((FIX::FieldBase const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase___str__(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase *","__str__", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = FIX_FieldBase___str__(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.<<

  call-seq:
    <<(stream, field) -> std::ostream
    <<(stream, message) -> std::ostream
    <<(stream, sessionID) -> std::ostream
    <<(?, ?) -> std::ostream

Left shifting or appending operator.
*/
SWIGINTERN VALUE
_wrap___lshift____SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ostream &","FIX::operator <<", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","FIX::operator <<", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::FieldBase const &","FIX::operator <<", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","FIX::operator <<", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::FieldBase const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassStringField;

SWIGINTERN VALUE
_wrap_new_StringField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::StringField";
  FIX::StringField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::StringField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::StringField", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::StringField", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::StringField *)new FIX::StringField(arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StringField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StringField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StringField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StringField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StringField";
  FIX::StringField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::StringField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::StringField *)new FIX::StringField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StringField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringField__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StringField__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringField.new", 
    "    StringField.new(int field, std::string const &data)\n"
    "    StringField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setValue", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setValue", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setValue((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  result = (std::string *) &((FIX::StringField const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::StringField.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_StringField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)((FIX::StringField const *)arg1)->operator <((FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::StringField.>

  call-seq:
    >(rhs) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap_StringField___gt__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)((FIX::StringField const *)arg1)->operator >((FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::StringField.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_StringField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)((FIX::StringField const *)arg1)->operator ==((FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::StringField.<=

  call-seq:
    <=(rhs) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_StringField___le__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const *","operator <=", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","operator <=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","operator <=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)((FIX::StringField const *)arg1)->operator <=((FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::StringField.>=

  call-seq:
    >=(rhs) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_StringField___ge__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const *","operator >=", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","operator >=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","operator >=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)((FIX::StringField const *)arg1)->operator >=((FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_StringField(FIX::StringField *arg1) {
    delete arg1;
}


/*
  Document-method: Quickfix::FIX.<

  call-seq:
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap___lt____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","FIX::operator <", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (bool)FIX::operator <((FIX::StringField const &)*arg1,(char const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___lt____SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","FIX::operator <", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator <((char const *)arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.>

  call-seq:
    >(lhs, rhs) -> bool
    >(lhs, rhs) -> bool
    >(lhs, rhs) -> bool
    >(lhs, rhs) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap___gt____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","FIX::operator >", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (bool)FIX::operator >((FIX::StringField const &)*arg1,(char const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___gt____SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","FIX::operator >", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator >((char const *)arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.==

  call-seq:
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap___eq____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator ==", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator ==", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","FIX::operator ==", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (bool)FIX::operator ==((FIX::StringField const &)*arg1,(char const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___eq____SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","FIX::operator ==", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator ==", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator ==", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator ==((char const *)arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.<=

  call-seq:
    <=(lhs, rhs) -> bool
    <=(lhs, rhs) -> bool
    <=(lhs, rhs) -> bool
    <=(lhs, rhs) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___le____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","FIX::operator <=", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (bool)FIX::operator <=((FIX::StringField const &)*arg1,(char const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___le____SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","FIX::operator <=", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator <=((char const *)arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.>=

  call-seq:
    >=(lhs, rhs) -> bool
    >=(lhs, rhs) -> bool
    >=(lhs, rhs) -> bool
    >=(lhs, rhs) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___ge____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","FIX::operator >=", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (bool)FIX::operator >=((FIX::StringField const &)*arg1,(char const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___ge____SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","FIX::operator >=", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator >=((char const *)arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.<

  call-seq:
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap___lt____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::operator <", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator <", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)FIX::operator <((FIX::StringField const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___lt____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::operator <", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator <", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator <((std::string const &)*arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.>

  call-seq:
    >(lhs, rhs) -> bool
    >(lhs, rhs) -> bool
    >(lhs, rhs) -> bool
    >(lhs, rhs) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap___gt____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::operator >", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator >", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)FIX::operator >((FIX::StringField const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___gt____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::operator >", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator >", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator >((std::string const &)*arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap___gt__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__gt__", 
    "    bool __gt__(FIX::StringField const &lhs, char const *rhs)\n"
    "    bool __gt__(char const *lhs, FIX::StringField const &rhs)\n"
    "    bool __gt__(FIX::StringField const &lhs, std::string const &rhs)\n"
    "    bool __gt__(std::string const &lhs, FIX::StringField const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.==

  call-seq:
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap___eq____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator ==", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator ==", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::operator ==", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator ==", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)FIX::operator ==((FIX::StringField const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___eq____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::operator ==", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator ==", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator ==", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator ==", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator ==((std::string const &)*arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.<=

  call-seq:
    <=(lhs, rhs) -> bool
    <=(lhs, rhs) -> bool
    <=(lhs, rhs) -> bool
    <=(lhs, rhs) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___le____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::operator <=", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator <=", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)FIX::operator <=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___le____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::operator <=", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator <=", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator <=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator <=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator <=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap___le__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__le__", 
    "    bool __le__(FIX::StringField const &lhs, char const *rhs)\n"
    "    bool __le__(char const *lhs, FIX::StringField const &rhs)\n"
    "    bool __le__(FIX::StringField const &lhs, std::string const &rhs)\n"
    "    bool __le__(std::string const &lhs, FIX::StringField const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.>=

  call-seq:
    >=(lhs, rhs) -> bool
    >=(lhs, rhs) -> bool
    >=(lhs, rhs) -> bool
    >=(lhs, rhs) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___ge____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::operator >=", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator >=", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)FIX::operator >=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap___ge____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::operator >=", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::operator >=", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::StringField const &","FIX::operator >=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::StringField const &","FIX::operator >=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  result = (bool)FIX::operator >=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap___ge__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__ge__", 
    "    bool __ge__(FIX::StringField const &lhs, char const *rhs)\n"
    "    bool __ge__(char const *lhs, FIX::StringField const &rhs)\n"
    "    bool __ge__(FIX::StringField const &lhs, std::string const &rhs)\n"
    "    bool __ge__(std::string const &lhs, FIX::StringField const &rhs)\n");
  
  return Qnil;
}


swig_class SwigClassCharField;

SWIGINTERN VALUE
_wrap_new_CharField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CharField";
  FIX::CharField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::CharField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","FIX::CharField", 2, argv[1] ));
  } 
  arg2 = static_cast< char >(val2);
  result = (FIX::CharField *)new FIX::CharField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CharField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CharField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CharField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CharField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CharField";
  FIX::CharField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::CharField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::CharField *)new FIX::CharField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CharField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CharField__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CharField__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "CharField.new", 
    "    CharField.new(int field, char data)\n"
    "    CharField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CharField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__CharField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CharField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::CharField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CharField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__CharField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CharField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::CharField * >(argp1);
  try {
    result = (char)((FIX::CharField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_CharField(FIX::CharField *arg1) {
    delete arg1;
}

swig_class SwigClassDoubleField;

SWIGINTERN VALUE
_wrap_new_DoubleField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoubleField";
  FIX::DoubleField *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::DoubleField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","FIX::DoubleField", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","FIX::DoubleField", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (FIX::DoubleField *)new FIX::DoubleField(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DoubleField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoubleField";
  FIX::DoubleField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::DoubleField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","FIX::DoubleField", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  result = (FIX::DoubleField *)new FIX::DoubleField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DoubleField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DoubleField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DoubleField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DoubleField__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoubleField";
  FIX::DoubleField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::DoubleField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::DoubleField *)new FIX::DoubleField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DoubleField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DoubleField__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DoubleField__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DoubleField__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "DoubleField.new", 
    "    DoubleField.new(int field, double data, int padding)\n"
    "    DoubleField.new(int field, double data)\n"
    "    DoubleField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DoubleField_setValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DoubleField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","setValue", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setValue(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DoubleField_setValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DoubleField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DoubleField_setValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DoubleField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleField_setValue__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DoubleField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleField_setValue__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "DoubleField.setValue", 
    "    void DoubleField.setValue(double value, int padding)\n"
    "    void DoubleField.setValue(double value)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DoubleField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DoubleField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  try {
    result = (double)((FIX::DoubleField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_DoubleField(FIX::DoubleField *arg1) {
    delete arg1;
}

swig_class SwigClassIntField;

SWIGINTERN VALUE
_wrap_new_IntField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IntField";
  FIX::IntField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::IntField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","FIX::IntField", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (FIX::IntField *)new FIX::IntField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IntField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IntField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IntField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IntField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IntField";
  FIX::IntField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::IntField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::IntField *)new FIX::IntField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IntField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IntField__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_IntField__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "IntField.new", 
    "    IntField.new(int field, int data)\n"
    "    IntField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__IntField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::IntField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::IntField * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__IntField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::IntField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::IntField * >(argp1);
  try {
    result = (int)((FIX::IntField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_IntField(FIX::IntField *arg1) {
    delete arg1;
}

swig_class SwigClassBoolField;

SWIGINTERN VALUE
_wrap_new_BoolField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BoolField";
  FIX::BoolField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::BoolField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::BoolField", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::BoolField *)new FIX::BoolField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BoolField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BoolField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BoolField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BoolField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BoolField";
  FIX::BoolField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::BoolField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::BoolField *)new FIX::BoolField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BoolField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BoolField__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BoolField__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "BoolField.new", 
    "    BoolField.new(int field, bool data)\n"
    "    BoolField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoolField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__BoolField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BoolField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoolField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__BoolField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BoolField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  try {
    result = (bool)((FIX::BoolField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_BoolField(FIX::BoolField *arg1) {
    delete arg1;
}

swig_class SwigClassUtcTimeStampField;

SWIGINTERN VALUE
_wrap_new_UtcTimeStampField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcTimeStamp *arg2 = 0 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  FIX::UtcTimeStampField *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeStampField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp const &","FIX::UtcTimeStampField", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","FIX::UtcTimeStampField", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FIX::UtcTimeStampField", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,(UtcTimeStamp const &)*arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UtcTimeStampField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcTimeStamp *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  FIX::UtcTimeStampField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeStampField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp const &","FIX::UtcTimeStampField", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","FIX::UtcTimeStampField", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,(UtcTimeStamp const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UtcTimeStampField__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  FIX::UtcTimeStampField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeStampField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::UtcTimeStampField", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UtcTimeStampField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UtcTimeStampField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UtcTimeStampField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UtcTimeStampField__SWIG_3(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  FIX::UtcTimeStampField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeStampField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UtcTimeStampField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcTimeStampField__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcTimeStampField__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeStampField__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeStampField__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UtcTimeStampField.new", 
    "    UtcTimeStampField.new(int field, UtcTimeStamp const &data, bool showMilliseconds)\n"
    "    UtcTimeStampField.new(int field, UtcTimeStamp const &data)\n"
    "    UtcTimeStampField.new(int field, bool showMilliseconds)\n"
    "    UtcTimeStampField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UtcTimeStampField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeStampField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  (arg1)->setValue(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UtcTimeStampField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UtcTimeStamp result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeStampField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  try {
    result = ((FIX::UtcTimeStampField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::UtcTimeStampField.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_UtcTimeStampField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeStampField const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcTimeStampField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcTimeStampField const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcTimeStampField const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator <((FIX::UtcTimeStampField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::UtcTimeStampField.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_UtcTimeStampField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeStampField const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcTimeStampField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcTimeStampField const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcTimeStampField const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator ==((FIX::UtcTimeStampField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_UtcTimeStampField(FIX::UtcTimeStampField *arg1) {
    delete arg1;
}

swig_class SwigClassUtcDateField;

SWIGINTERN VALUE
_wrap_new_UtcDateField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcDate *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcDateField";
  FIX::UtcDateField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcDateField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_UtcDate,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcDate const &","FIX::UtcDateField", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcDate const &","FIX::UtcDateField", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< UtcDate * >(argp2);
  result = (FIX::UtcDateField *)new FIX::UtcDateField(arg1,(UtcDate const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UtcDateField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UtcDateField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UtcDateField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UtcDateField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcDateField";
  FIX::UtcDateField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcDateField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::UtcDateField *)new FIX::UtcDateField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UtcDateField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcDateField__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UtcDate, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcDateField__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "UtcDateField.new", 
    "    UtcDateField.new(int field, UtcDate const &data)\n"
    "    UtcDateField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UtcDateField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  UtcDate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcDateField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcDate,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcDate &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcDate &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcDate * >(argp2);
  (arg1)->setValue(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UtcDateField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UtcDate result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcDateField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  try {
    result = ((FIX::UtcDateField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new UtcDate(static_cast< const UtcDate& >(result))), SWIGTYPE_p_UtcDate, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::UtcDateField.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_UtcDateField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcDateField const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcDateField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcDateField const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcDateField const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  result = (bool)((FIX::UtcDateField const *)arg1)->operator <((FIX::UtcDateField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::UtcDateField.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_UtcDateField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcDateField const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcDateField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcDateField const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcDateField const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  result = (bool)((FIX::UtcDateField const *)arg1)->operator ==((FIX::UtcDateField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_UtcDateField(FIX::UtcDateField *arg1) {
    delete arg1;
}

swig_class SwigClassUtcTimeOnlyField;

SWIGINTERN VALUE
_wrap_new_UtcTimeOnlyField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcTimeOnly *arg2 = 0 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeOnlyField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_UtcTimeOnly,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeOnly const &","FIX::UtcTimeOnlyField", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeOnly const &","FIX::UtcTimeOnlyField", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FIX::UtcTimeOnlyField", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,(UtcTimeOnly const &)*arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UtcTimeOnlyField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcTimeOnly *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeOnlyField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_UtcTimeOnly,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeOnly const &","FIX::UtcTimeOnlyField", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeOnly const &","FIX::UtcTimeOnlyField", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,(UtcTimeOnly const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UtcTimeOnlyField__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeOnlyField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::UtcTimeOnlyField", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UtcTimeOnlyField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UtcTimeOnlyField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UtcTimeOnlyField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UtcTimeOnlyField__SWIG_3(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::UtcTimeOnlyField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UtcTimeOnlyField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UtcTimeOnlyField__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UtcTimeOnly, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcTimeOnlyField__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeOnlyField__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UtcTimeOnly, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeOnlyField__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UtcTimeOnlyField.new", 
    "    UtcTimeOnlyField.new(int field, UtcTimeOnly const &data, bool showMilliseconds)\n"
    "    UtcTimeOnlyField.new(int field, UtcTimeOnly const &data)\n"
    "    UtcTimeOnlyField.new(int field, bool showMilliseconds)\n"
    "    UtcTimeOnlyField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UtcTimeOnlyField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  UtcTimeOnly *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeOnlyField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcTimeOnly,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeOnly &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeOnly &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  (arg1)->setValue(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UtcTimeOnlyField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UtcTimeOnly result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeOnlyField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  try {
    result = ((FIX::UtcTimeOnlyField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new UtcTimeOnly(static_cast< const UtcTimeOnly& >(result))), SWIGTYPE_p_UtcTimeOnly, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::UtcTimeOnlyField.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_UtcTimeOnlyField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeOnlyField const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcTimeOnlyField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcTimeOnlyField const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcTimeOnlyField const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator <((FIX::UtcTimeOnlyField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::UtcTimeOnlyField.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_UtcTimeOnlyField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UtcTimeOnlyField const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcTimeOnlyField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcTimeOnlyField const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcTimeOnlyField const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator ==((FIX::UtcTimeOnlyField const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_UtcTimeOnlyField(FIX::UtcTimeOnlyField *arg1) {
    delete arg1;
}

swig_class SwigClassCheckSumField;

SWIGINTERN VALUE
_wrap_new_CheckSumField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSumField";
  FIX::CheckSumField *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::CheckSumField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","FIX::CheckSumField", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (FIX::CheckSumField *)new FIX::CheckSumField(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CheckSumField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CheckSumField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CheckSumField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CheckSumField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSumField";
  FIX::CheckSumField *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::CheckSumField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (FIX::CheckSumField *)new FIX::CheckSumField(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CheckSumField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CheckSumField__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CheckSumField__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "CheckSumField.new", 
    "    CheckSumField.new(int field, int data)\n"
    "    CheckSumField.new(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CheckSumField_setValue(int argc, VALUE *argv, VALUE self) {
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__CheckSumField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CheckSumField *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::CheckSumField * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CheckSumField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__CheckSumField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CheckSumField const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::CheckSumField * >(argp1);
  try {
    result = (int)((FIX::CheckSumField const *)arg1)->getValue();
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_CheckSumField(FIX::CheckSumField *arg1) {
    delete arg1;
}

swig_class SwigClassFieldMap;

SWIGINTERN VALUE
_wrap_new_FieldMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
  message_order *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  FIX::FieldMap *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_message_order,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "message_order const &","FIX::FieldMap", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "message_order const &","FIX::FieldMap", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  result = (FIX::FieldMap *)new FIX::FieldMap((message_order const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FieldMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  FIX::FieldMap *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FieldMap *)new FIX::FieldMap();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FieldMap__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  FIX::FieldMap *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int const []","FIX::FieldMap", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< int * >(argp1);
  result = (FIX::FieldMap *)new FIX::FieldMap((int const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FieldMap_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FieldMap_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FieldMap);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FieldMap__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  FIX::FieldMap *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const &","FIX::FieldMap", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldMap const &","FIX::FieldMap", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = (FIX::FieldMap *)new FIX::FieldMap((FIX::FieldMap const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FieldMap(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FieldMap__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_message_order, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FieldMap.new", 
    "    FieldMap.new(message_order const &order)\n"
    "    FieldMap.new()\n"
    "    FieldMap.new(int const order[])\n"
    "    FieldMap.new(FIX::FieldMap const &copy)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FieldMap(FIX::FieldMap *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FieldMap_setField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","setField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::FieldBase const &","setField", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","setField", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setField", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  try {
    (arg1)->setField((FIX::FieldBase const &)*arg2,arg3);
  }
  catch(FIX::RepeatedTag &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RepeatedTag, SWIG_NewPointerObj((new FIX::RepeatedTag(static_cast< const FIX::RepeatedTag& >(_e))),SWIGTYPE_p_FIX__RepeatedTag,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_setField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","setField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::FieldBase const &","setField", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","setField", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  try {
    (arg1)->setField((FIX::FieldBase const &)*arg2);
  }
  catch(FIX::RepeatedTag &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RepeatedTag, SWIG_NewPointerObj((new FIX::RepeatedTag(static_cast< const FIX::RepeatedTag& >(_e))),SWIGTYPE_p_FIX__RepeatedTag,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_setField__SWIG_2(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","setField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","setField", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setField", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  try {
    (arg1)->setField(arg2,(std::string const &)*arg3);
  }
  catch(FIX::RepeatedTag &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RepeatedTag, SWIG_NewPointerObj((new FIX::RepeatedTag(static_cast< const FIX::RepeatedTag& >(_e))),SWIGTYPE_p_FIX__RepeatedTag,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::NoTagValue &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__NoTagValue, SWIG_NewPointerObj((new FIX::NoTagValue(static_cast< const FIX::NoTagValue& >(_e))),SWIGTYPE_p_FIX__NoTagValue,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_setField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_setField__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_setField__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FieldMap_setField__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FieldMap.setField", 
    "    void FieldMap.setField(FIX::FieldBase const &field, bool overwrite)\n"
    "    void FieldMap.setField(FIX::FieldBase const &field)\n"
    "    void FieldMap.setField(int field, std::string const &value)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::FieldBase &","getField", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase &","getField", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  try {
    result = (FIX::FieldBase *) &((FIX::FieldMap const *)arg1)->getField(*arg2);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    result = (std::string *) &((FIX::FieldMap const *)arg1)->getField(arg2);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_getField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_getField__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_getField__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FieldMap.getField", 
    "    std::string const & FieldMap.getField(FIX::FieldBase &field)\n"
    "    std::string const & FieldMap.getField(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getFieldRef(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::FieldBase *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getFieldRef", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFieldRef", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    result = (FIX::FieldBase *) &((FIX::FieldMap const *)arg1)->getFieldRef(arg2);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getFieldPtr(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FIX::FieldBase *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getFieldPtr", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFieldPtr", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    result = (FIX::FieldBase *)((FIX::FieldMap const *)arg1)->getFieldPtr(arg2);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_isSetField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","isSetField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::FieldBase const &","isSetField", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","isSetField", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  result = (bool)((FIX::FieldMap const *)arg1)->isSetField((FIX::FieldBase const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_isSetField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","isSetField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isSetField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::FieldMap const *)arg1)->isSetField(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_isSetField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_isSetField__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_isSetField__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FieldMap.isSetField", 
    "    bool FieldMap.isSetField(FIX::FieldBase const &field)\n"
    "    bool FieldMap.isSetField(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_removeField(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","removeField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","removeField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeField(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_addGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","addGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::FieldMap const &","addGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldMap const &","addGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","addGroup", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->addGroup(arg2,(FIX::FieldMap const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_addGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","addGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::FieldMap const &","addGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldMap const &","addGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  (arg1)->addGroup(arg2,(FIX::FieldMap const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_addGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FieldMap_addGroup__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        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_addGroup__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FieldMap.addGroup", 
    "    void FieldMap.addGroup(int field, FIX::FieldMap const &group, bool setCount)\n"
    "    void FieldMap.addGroup(int field, FIX::FieldMap const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_replaceGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","replaceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","replaceGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","replaceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::FieldMap &","replaceGroup", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldMap &","replaceGroup", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  (arg1)->replaceGroup(arg2,arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  FIX::FieldMap *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::FieldMap &","getGroup", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldMap &","getGroup", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  try {
    result = (FIX::FieldMap *) &((FIX::FieldMap const *)arg1)->getGroup(arg2,arg3,*arg4);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getGroupRef(int argc, VALUE *argv, VALUE self) {
  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 ;
  FIX::FieldMap *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getGroupRef", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getGroupRef", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getGroupRef", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  try {
    result = (FIX::FieldMap *) &((FIX::FieldMap const *)arg1)->getGroupRef(arg2,arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getGroupPtr(int argc, VALUE *argv, VALUE self) {
  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 ;
  FIX::FieldMap *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","getGroupPtr", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getGroupPtr", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getGroupPtr", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  try {
    result = (FIX::FieldMap *)((FIX::FieldMap const *)arg1)->getGroupPtr(arg2,arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_removeGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","removeGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","removeGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","removeGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->removeGroup(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_removeGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","removeGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","removeGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_removeGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_removeGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_removeGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FieldMap.removeGroup", 
    "    void FieldMap.removeGroup(int num, int field)\n"
    "    void FieldMap.removeGroup(int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_hasGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","hasGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","hasGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::FieldMap const *)arg1)->hasGroup(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_hasGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","hasGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","hasGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","hasGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)((FIX::FieldMap const *)arg1)->hasGroup(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_hasGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_hasGroup__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_hasGroup__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FieldMap.hasGroup", 
    "    bool FieldMap.hasGroup(int field)\n"
    "    bool FieldMap.hasGroup(int num, int field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_groupCount(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","groupCount", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","groupCount", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((FIX::FieldMap const *)arg1)->groupCount(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_clear(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_isEmpty(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap *","isEmpty", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = (bool)(arg1)->isEmpty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_totalFields(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","totalFields", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = (int)((FIX::FieldMap const *)arg1)->totalFields();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","calculateString", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (std::string *) &((FIX::FieldMap const *)arg1)->calculateString(*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  result = (std::string *) &((FIX::FieldMap const *)arg1)->calculateString(*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_calculateString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_calculateString__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_calculateString__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FieldMap.calculateString", 
    "    std::string & FieldMap.calculateString(std::string &, bool clear)\n"
    "    std::string & FieldMap.calculateString(std::string &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","calculateLength", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","calculateLength", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","calculateLength", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2,arg3,arg4);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateLength__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","calculateLength", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","calculateLength", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateLength__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","calculateLength", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateLength__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = (int)((FIX::FieldMap const *)arg1)->calculateLength();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_calculateLength(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_calculateLength__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_calculateLength__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_calculateLength__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FieldMap_calculateLength__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FieldMap.calculateLength", 
    "    int FieldMap.calculateLength(int beginStringField, int bodyLengthField, int checkSumField)\n"
    "    int FieldMap.calculateLength(int beginStringField, int bodyLengthField)\n"
    "    int FieldMap.calculateLength(int beginStringField)\n"
    "    int FieldMap.calculateLength()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateTotal__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateTotal", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","calculateTotal", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((FIX::FieldMap const *)arg1)->calculateTotal(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateTotal__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","calculateTotal", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = (int)((FIX::FieldMap const *)arg1)->calculateTotal();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FieldMap_calculateTotal(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_calculateTotal__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_calculateTotal__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FieldMap.calculateTotal", 
    "    int FieldMap.calculateTotal(int checkSumField)\n"
    "    int FieldMap.calculateTotal()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_begin(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap::iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = ((FIX::FieldMap const *)arg1)->begin();
  vresult = SWIG_NewPointerObj((new FIX::FieldMap::iterator(static_cast< const FIX::FieldMap::iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Fields__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_end(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap::iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = ((FIX::FieldMap const *)arg1)->end();
  vresult = SWIG_NewPointerObj((new FIX::FieldMap::iterator(static_cast< const FIX::FieldMap::iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Fields__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_g_begin(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap::g_iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","g_begin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = ((FIX::FieldMap const *)arg1)->g_begin();
  vresult = SWIG_NewPointerObj((new FIX::FieldMap::g_iterator(static_cast< const FIX::FieldMap::g_iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Groups__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_g_end(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::FieldMap::g_iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldMap const *","g_end", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  result = ((FIX::FieldMap const *)arg1)->g_end();
  vresult = SWIG_NewPointerObj((new FIX::FieldMap::g_iterator(static_cast< const FIX::FieldMap::g_iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Groups__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_headerOrder_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(FIX::headerOrder), SWIGTYPE_p_int,  0 );
  return _val;
}


swig_class SwigClassHeader;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Header_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Header_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Header);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Header(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Header";
  FIX::Header *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Header *)new FIX::Header();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_Header(FIX::Header *arg1) {
    delete arg1;
}

swig_class SwigClassTrailer;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Trailer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Trailer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Trailer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Trailer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Trailer";
  FIX::Trailer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Trailer *)new FIX::Trailer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_Trailer(FIX::Trailer *arg1) {
    delete arg1;
}

swig_class SwigClassMessage;

SWIGINTERN VALUE
_wrap_new_Message__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Message *)new FIX::Message();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Message__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::Message", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  try {
    result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,arg2);
    DATA_PTR(self) = result;
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Message__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  try {
    result = (FIX::Message *)new FIX::Message((std::string const &)*arg1);
    DATA_PTR(self) = result;
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Message__SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::Message", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::Message", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FIX::Message", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  try {
    result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,arg3);
    DATA_PTR(self) = result;
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Message__SWIG_4(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::Message", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::Message", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  try {
    result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2);
    DATA_PTR(self) = result;
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Message__SWIG_5(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  FIX::DataDictionary *arg3 = 0 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::Message", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::Message", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::Message", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::Message", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","FIX::Message", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  try {
    result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3,arg4);
    DATA_PTR(self) = result;
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Message__SWIG_6(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  FIX::DataDictionary *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::Message", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::Message", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::Message", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::Message", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  try {
    result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3);
    DATA_PTR(self) = result;
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Message_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Message_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Message);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Message__SWIG_7(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  FIX::Message *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const &","FIX::Message", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","FIX::Message", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (FIX::Message *)new FIX::Message((FIX::Message const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Message(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Message__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Message__SWIG_7(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Message__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Message__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Message__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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_new_Message__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Message__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Message__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Message.new", 
    "    Message.new()\n"
    "    Message.new(std::string const &string, bool validate)\n"
    "    Message.new(std::string const &string)\n"
    "    Message.new(std::string const &string, FIX::DataDictionary const &dataDictionary, bool validate)\n"
    "    Message.new(std::string const &string, FIX::DataDictionary const &dataDictionary)\n"
    "    Message.new(std::string const &string, FIX::DataDictionary const &sessionDataDictionary, FIX::DataDictionary const &applicationDataDictionary, bool validate)\n"
    "    Message.new(std::string const &string, FIX::DataDictionary const &sessionDataDictionary, FIX::DataDictionary const &applicationDataDictionary)\n"
    "    Message.new(FIX::Message const &copy)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_InitializeXML(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Message::InitializeXML", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Message::InitializeXML", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (bool)FIX::Message::InitializeXML((std::string const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_addGroup(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","addGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Group &","addGroup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","addGroup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  (arg1)->addGroup(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_replaceGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","replaceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","replaceGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","replaceGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","replaceGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  (arg1)->replaceGroup(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  Group *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","getGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","getGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  try {
    result = (Group *) &((FIX::Message const *)arg1)->getGroup(arg2,*arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Group, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_removeGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","removeGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","removeGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","removeGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","removeGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  (arg1)->removeGroup(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_removeGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","removeGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Group &","removeGroup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","removeGroup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  (arg1)->removeGroup(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_removeGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_removeGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Message_removeGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Message.removeGroup", 
    "    void Message.removeGroup(unsigned int num, FIX::Group &group)\n"
    "    void Message.removeGroup(FIX::Group &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_hasGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","hasGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Group const &","hasGroup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group const &","hasGroup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  result = (bool)((FIX::Message const *)arg1)->hasGroup((FIX::Group const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_hasGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","hasGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","hasGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","hasGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","hasGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  result = (bool)((FIX::Message const *)arg1)->hasGroup(arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_hasGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_hasGroup__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Message_hasGroup__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Message.hasGroup", 
    "    bool Message.hasGroup(FIX::Group const &group)\n"
    "    bool Message.hasGroup(unsigned int num, FIX::Group &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","toString", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","toString", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","toString", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = ((FIX::Message const *)arg1)->toString(arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","toString", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","toString", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = ((FIX::Message const *)arg1)->toString(arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","toString", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = ((FIX::Message const *)arg1)->toString(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = ((FIX::Message const *)arg1)->toString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_4(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","toString", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","toString", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","toString", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_5(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","toString", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","toString", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_6(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","toString", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toString__SWIG_7(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_toString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_toString__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_toString__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_toString__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_toString__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_toString__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Message_toString__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Message_toString__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Message_toString__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Message.toString", 
    "    std::string & Message.toString(int beginStringField, int bodyLengthField, int checkSumField)\n"
    "    std::string & Message.toString(int beginStringField, int bodyLengthField)\n"
    "    std::string & Message.toString(int beginStringField)\n"
    "    std::string & Message.toString()\n"
    "    std::string & Message.toString(std::string &, int beginStringField, int bodyLengthField, int checkSumField)\n"
    "    std::string & Message.toString(std::string &, int beginStringField, int bodyLengthField)\n"
    "    std::string & Message.toString(std::string &, int beginStringField)\n"
    "    std::string & Message.toString(std::string &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toXML__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toXML", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = ((FIX::Message const *)arg1)->toXML();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toXML__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","toXML", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  result = (std::string *) &((FIX::Message const *)arg1)->toXML(*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_toXML(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_toXML__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_toXML__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Message.toXML", 
    "    std::string & Message.toXML()\n"
    "    std::string & Message.toXML(std::string &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_reverseRoute(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Header *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","reverseRoute", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Header,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Header const &","reverseRoute", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Header const &","reverseRoute", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Header * >(argp2);
  (arg1)->reverseRoute((FIX::Header const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    (arg1)->setString((std::string const &)*arg2);
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setString", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  try {
    (arg1)->setString((std::string const &)*arg2,arg3);
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setString__SWIG_2(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setString", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","setString", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< FIX::DataDictionary * >(argp4);
  try {
    (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4);
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setString__SWIG_3(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setString", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","setString", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< FIX::DataDictionary * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","setString", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  try {
    (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4,(FIX::DataDictionary const *)arg5);
  }
  catch(FIX::InvalidMessage &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__InvalidMessage, SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_setString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_setString__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_setString__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Message_setString__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Message_setString__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Message.setString", 
    "    void Message.setString(std::string const &string)\n"
    "    void Message.setString(std::string const &string, bool validate)\n"
    "    void Message.setString(std::string const &string, bool validate, FIX::DataDictionary const *pDataDictionary)\n"
    "    void Message.setString(std::string const &string, bool validate, FIX::DataDictionary const *pSessionDataDictionary, FIX::DataDictionary const *pApplicationDataDictionary)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::FieldBase const &","setGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","setGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::FieldBase * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::string const &","setGroup", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setGroup", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_std__string__size_type,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "std::string::size_type &","setGroup", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string::size_type &","setGroup", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< std::string::size_type * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FIX::FieldMap &","setGroup", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldMap &","setGroup", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< FIX::FieldMap * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7, SWIGTYPE_p_DataDictionary,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "DataDictionary const &","setGroup", 7, argv[5] )); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "DataDictionary const &","setGroup", 7, argv[5])); 
  }
  arg7 = reinterpret_cast< DataDictionary * >(argp7);
  (arg1)->setGroup((std::string const &)*arg2,(FIX::FieldBase const &)*arg3,(std::string const &)*arg4,*arg5,*arg6,(DataDictionary const &)*arg7);
  vresult = rb_ary_new();
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setStringHeader(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setStringHeader", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setStringHeader", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setStringHeader", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setStringHeader((std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getHeader__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Header *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","getHeader", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (FIX::Header *) &((FIX::Message const *)arg1)->getHeader();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getHeader__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Header *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","getHeader", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (FIX::Header *) &(arg1)->getHeader();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_getHeader(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getHeader__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getHeader__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Message.getHeader", 
    "    FIX::Header & Message.getHeader()\n"
    "    FIX::Header & Message.getHeader()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getTrailer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Trailer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","getTrailer", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (FIX::Trailer *) &((FIX::Message const *)arg1)->getTrailer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getTrailer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Trailer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","getTrailer", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (FIX::Trailer *) &(arg1)->getTrailer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_getTrailer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getTrailer__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getTrailer__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Message.getTrailer", 
    "    FIX::Trailer & Message.getTrailer()\n"
    "    FIX::Trailer & Message.getTrailer()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_hasValidStructure(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","hasValidStructure", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = NUM2INT(argv[0]);
    arg2 = &temp2;
  }
  result = (bool)((FIX::Message const *)arg1)->hasValidStructure(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("int &") == "int &" )
    {
      vresult = result ? SWIG_From_int(static_cast< int >(*arg2)) : Qnil;
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_bodyLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","bodyLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","bodyLength", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","bodyLength", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","bodyLength", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (int)((FIX::Message const *)arg1)->bodyLength(arg2,arg3,arg4);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_bodyLength__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","bodyLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","bodyLength", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","bodyLength", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((FIX::Message const *)arg1)->bodyLength(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_bodyLength__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","bodyLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","bodyLength", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((FIX::Message const *)arg1)->bodyLength(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_bodyLength__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","bodyLength", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (int)((FIX::Message const *)arg1)->bodyLength();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_bodyLength(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_bodyLength__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_bodyLength__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Message_bodyLength__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Message_bodyLength__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Message.bodyLength", 
    "    int Message.bodyLength(int beginStringField, int bodyLengthField, int checkSumField)\n"
    "    int Message.bodyLength(int beginStringField, int bodyLengthField)\n"
    "    int Message.bodyLength(int beginStringField)\n"
    "    int Message.bodyLength()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_checkSum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","checkSum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","checkSum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((FIX::Message const *)arg1)->checkSum(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_checkSum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","checkSum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (int)((FIX::Message const *)arg1)->checkSum();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_checkSum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_checkSum__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_checkSum__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Message.checkSum", 
    "    int Message.checkSum(int checkSumField)\n"
    "    int Message.checkSum()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isAdmin(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","isAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (bool)((FIX::Message const *)arg1)->isAdmin();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isApp(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","isApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (bool)((FIX::Message const *)arg1)->isApp();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isEmpty(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","isEmpty", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = (bool)(arg1)->isEmpty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_clear(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isAdminMsgType(int argc, VALUE *argv, VALUE self) {
  MsgType *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_MsgType,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MsgType const &","FIX::Message::isAdminMsgType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "MsgType const &","FIX::Message::isAdminMsgType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< MsgType * >(argp1);
  result = (bool)FIX::Message::isAdminMsgType((MsgType const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toApplVerID(int argc, VALUE *argv, VALUE self) {
  BeginString *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ApplVerID result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_BeginString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "BeginString const &","FIX::Message::toApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "BeginString const &","FIX::Message::toApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< BeginString * >(argp1);
  result = FIX::Message::toApplVerID((BeginString const &)*arg1);
  vresult = SWIG_NewPointerObj((new ApplVerID(static_cast< const ApplVerID& >(result))), SWIGTYPE_p_ApplVerID, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toBeginString(int argc, VALUE *argv, VALUE self) {
  ApplVerID *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  BeginString result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_ApplVerID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ApplVerID const &","FIX::Message::toBeginString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ApplVerID const &","FIX::Message::toBeginString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< ApplVerID * >(argp1);
  result = FIX::Message::toBeginString((ApplVerID const &)*arg1);
  vresult = SWIG_NewPointerObj((new BeginString(static_cast< const BeginString& >(result))), SWIGTYPE_p_BeginString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isHeaderField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::Message::isHeaderField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (bool)FIX::Message::isHeaderField(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isHeaderField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = 0 ;
  DataDictionary *arg2 = (DataDictionary *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const &","FIX::Message::isHeaderField", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","FIX::Message::isHeaderField", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "DataDictionary const *","FIX::Message::isHeaderField", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< DataDictionary * >(argp2);
  result = (bool)FIX::Message::isHeaderField((FIX::FieldBase const &)*arg1,(DataDictionary const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isHeaderField__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const &","FIX::Message::isHeaderField", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","FIX::Message::isHeaderField", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (bool)FIX::Message::isHeaderField((FIX::FieldBase const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_isHeaderField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_isHeaderField__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Message_isHeaderField__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isHeaderField__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Message.isHeaderField", 
    "    bool Message.isHeaderField(int field)\n"
    "    bool Message.isHeaderField(FIX::FieldBase const &field, DataDictionary const *pD)\n"
    "    bool Message.isHeaderField(FIX::FieldBase const &field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isTrailerField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::Message::isTrailerField", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (bool)FIX::Message::isTrailerField(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isTrailerField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = 0 ;
  DataDictionary *arg2 = (DataDictionary *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const &","FIX::Message::isTrailerField", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","FIX::Message::isTrailerField", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "DataDictionary const *","FIX::Message::isTrailerField", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< DataDictionary * >(argp2);
  result = (bool)FIX::Message::isTrailerField((FIX::FieldBase const &)*arg1,(DataDictionary const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isTrailerField__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FieldBase const &","FIX::Message::isTrailerField", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FieldBase const &","FIX::Message::isTrailerField", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  result = (bool)FIX::Message::isTrailerField((FIX::FieldBase const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_isTrailerField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_isTrailerField__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Message_isTrailerField__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isTrailerField__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Message.isTrailerField", 
    "    bool Message.isTrailerField(int field)\n"
    "    bool Message.isTrailerField(FIX::FieldBase const &field, DataDictionary const *pD)\n"
    "    bool Message.isTrailerField(FIX::FieldBase const &field)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SessionID result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","getSessionID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getSessionID", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getSessionID", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    result = ((FIX::Message const *)arg1)->getSessionID((std::string const &)*arg2);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new SessionID(static_cast< const SessionID& >(result))), SWIGTYPE_p_SessionID, SWIG_POINTER_OWN |  0 );
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getSessionID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SessionID result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const *","getSessionID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  try {
    result = ((FIX::Message const *)arg1)->getSessionID();
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new SessionID(static_cast< const SessionID& >(result))), SWIGTYPE_p_SessionID, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Message_getSessionID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getSessionID__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_getSessionID__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Message.getSessionID", 
    "    SessionID Message.getSessionID(std::string const &qualifier)\n"
    "    SessionID Message.getSessionID()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_setSessionID(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","setSessionID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "SessionID const &","setSessionID", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SessionID const &","setSessionID", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< SessionID * >(argp2);
  (arg1)->setSessionID((SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message___str__(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message *","__str__", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  result = FIX_Message___str__(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_Message(FIX::Message *arg1) {
    delete arg1;
}


/*
  Document-method: Quickfix::FIX.<<

  call-seq:
    <<(stream, field) -> std::ostream
    <<(stream, message) -> std::ostream
    <<(stream, sessionID) -> std::ostream
    <<(?, ?) -> std::ostream

Left shifting or appending operator.
*/
SWIGINTERN VALUE
_wrap___lshift____SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::Message *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ostream &","FIX::operator <<", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","FIX::operator <<", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","FIX::operator <<", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","FIX::operator <<", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::Message const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_identifyType(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  MsgType result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::identifyType", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::identifyType", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  try {
    result = FIX::identifyType((std::string const &)*arg1);
  }
  catch(FIX::MessageParseError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__MessageParseError, SWIG_NewPointerObj((new FIX::MessageParseError(static_cast< const FIX::MessageParseError& >(_e))),SWIGTYPE_p_FIX__MessageParseError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new MsgType(static_cast< const MsgType& >(result))), SWIGTYPE_p_MsgType, SWIG_POINTER_OWN |  0 );
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


swig_class SwigClassGroup;

SWIGINTERN VALUE
_wrap_new_Group__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  FIX::Group *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::Group", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","FIX::Group", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (FIX::Group *)new FIX::Group(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Group__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  int *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  FIX::Group *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::Group", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","FIX::Group", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const []","FIX::Group", 3, argv[2] )); 
  } 
  arg3 = reinterpret_cast< int * >(argp3);
  result = (FIX::Group *)new FIX::Group(arg1,arg2,(int const (*))arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Group__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  message_order *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  FIX::Group *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","FIX::Group", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","FIX::Group", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_message_order,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "message_order const &","FIX::Group", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "message_order const &","FIX::Group", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  result = (FIX::Group *)new FIX::Group(arg1,arg2,(message_order const &)*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Group_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Group_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Group);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Group__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  FIX::Group *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group const &","FIX::Group", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group const &","FIX::Group", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  result = (FIX::Group *)new FIX::Group((FIX::Group const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Group(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Group__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Group__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_message_order, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Group__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Group__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Group.new", 
    "    Group.new(int field, int delim)\n"
    "    Group.new(int field, int delim, int const order[])\n"
    "    Group.new(int field, int delim, message_order const &order)\n"
    "    Group.new(FIX::Group const &copy)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_field(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group const *","field", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  result = (int)((FIX::Group const *)arg1)->field();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_delim(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group const *","delim", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  result = (int)((FIX::Group const *)arg1)->delim();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_addGroup(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group *","addGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Group &","addGroup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","addGroup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  (arg1)->addGroup(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_replaceGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group *","replaceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","replaceGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","replaceGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","replaceGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  (arg1)->replaceGroup(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_getGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  FIX::Group *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","getGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","getGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  try {
    result = (FIX::Group *) &((FIX::Group const *)arg1)->getGroup(arg2,*arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_removeGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group *","removeGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","removeGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","removeGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","removeGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  (arg1)->removeGroup(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_removeGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group *","removeGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Group &","removeGroup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","removeGroup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  (arg1)->removeGroup(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Group_removeGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Group_removeGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Group_removeGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Group.removeGroup", 
    "    void Group.removeGroup(unsigned int num, FIX::Group &group)\n"
    "    void Group.removeGroup(FIX::Group &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_hasGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  FIX::Group *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group *","hasGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Group const &","hasGroup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group const &","hasGroup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  result = (bool)(arg1)->hasGroup((FIX::Group const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_hasGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Group *","hasGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","hasGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Group &","hasGroup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Group &","hasGroup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  result = (bool)(arg1)->hasGroup(arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Group_hasGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Group_hasGroup__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Group_hasGroup__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Group.hasGroup", 
    "    bool Group.hasGroup(FIX::Group const &group)\n"
    "    bool Group.hasGroup(unsigned int num, FIX::Group &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Group(FIX::Group *arg1) {
    delete arg1;
}

swig_class SwigClassMaxPriceLevels;

SWIGINTERN VALUE
_wrap_new_MaxPriceLevels__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceLevels";
  FIX::MaxPriceLevels *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaxPriceLevels *)new FIX::MaxPriceLevels();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaxPriceLevels_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaxPriceLevels_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaxPriceLevels);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaxPriceLevels__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceLevels";
  FIX::MaxPriceLevels *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MaxPriceLevels", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MaxPriceLevels", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MaxPriceLevels *)new FIX::MaxPriceLevels((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaxPriceLevels(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaxPriceLevels__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxPriceLevels__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaxPriceLevels.new", 
    "    MaxPriceLevels.new()\n"
    "    MaxPriceLevels.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxPriceLevels(FIX::MaxPriceLevels *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEncodedIssuer;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuer";
  FIX::DerivativeEncodedIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEncodedIssuer *)new FIX::DerivativeEncodedIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEncodedIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEncodedIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEncodedIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuer";
  FIX::DerivativeEncodedIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::DerivativeEncodedIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::DerivativeEncodedIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::DerivativeEncodedIssuer *)new FIX::DerivativeEncodedIssuer((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEncodedIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEncodedIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEncodedIssuer.new", 
    "    DerivativeEncodedIssuer.new()\n"
    "    DerivativeEncodedIssuer.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedIssuer(FIX::DerivativeEncodedIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassNoCompIDs;

SWIGINTERN VALUE
_wrap_new_NoCompIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoCompIDs";
  FIX::NoCompIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoCompIDs *)new FIX::NoCompIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoCompIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoCompIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoCompIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoCompIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCompIDs";
  FIX::NoCompIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoCompIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoCompIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoCompIDs *)new FIX::NoCompIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoCompIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoCompIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoCompIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoCompIDs.new", 
    "    NoCompIDs.new()\n"
    "    NoCompIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoCompIDs(FIX::NoCompIDs *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstRefID;

SWIGINTERN VALUE
_wrap_new_SettlInstRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstRefID";
  FIX::SettlInstRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstRefID *)new FIX::SettlInstRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstRefID";
  FIX::SettlInstRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlInstRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlInstRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlInstRefID *)new FIX::SettlInstRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstRefID.new", 
    "    SettlInstRefID.new()\n"
    "    SettlInstRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstRefID(FIX::SettlInstRefID *arg1) {
    delete arg1;
}

swig_class SwigClassNestedPartyID;

SWIGINTERN VALUE
_wrap_new_NestedPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyID";
  FIX::NestedPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedPartyID *)new FIX::NestedPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyID";
  FIX::NestedPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NestedPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NestedPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NestedPartyID *)new FIX::NestedPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedPartyID.new", 
    "    NestedPartyID.new()\n"
    "    NestedPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartyID(FIX::NestedPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassDetachmentPoint;

SWIGINTERN VALUE
_wrap_new_DetachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DetachmentPoint";
  FIX::DetachmentPoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DetachmentPoint *)new FIX::DetachmentPoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DetachmentPoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DetachmentPoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DetachmentPoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DetachmentPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DetachmentPoint";
  FIX::DetachmentPoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::DetachmentPoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::DetachmentPoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::DetachmentPoint *)new FIX::DetachmentPoint((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DetachmentPoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DetachmentPoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DetachmentPoint__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DetachmentPoint.new", 
    "    DetachmentPoint.new()\n"
    "    DetachmentPoint.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DetachmentPoint(FIX::DetachmentPoint *arg1) {
    delete arg1;
}

swig_class SwigClassLateIndicator;

SWIGINTERN VALUE
_wrap_new_LateIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LateIndicator";
  FIX::LateIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LateIndicator *)new FIX::LateIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LateIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LateIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LateIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LateIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LateIndicator";
  FIX::LateIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::LateIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::LateIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::LateIndicator *)new FIX::LateIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LateIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LateIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LateIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LateIndicator.new", 
    "    LateIndicator.new()\n"
    "    LateIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LateIndicator(FIX::LateIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityListID;

SWIGINTERN VALUE
_wrap_new_SecurityListID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityListID";
  FIX::SecurityListID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityListID *)new FIX::SecurityListID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityListID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityListID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityListID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityListID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListID";
  FIX::SecurityListID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityListID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityListID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityListID *)new FIX::SecurityListID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityListID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityListID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityListID.new", 
    "    SecurityListID.new()\n"
    "    SecurityListID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListID(FIX::SecurityListID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_DerivativeFlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFlowScheduleType";
  FIX::DerivativeFlowScheduleType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeFlowScheduleType *)new FIX::DerivativeFlowScheduleType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeFlowScheduleType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeFlowScheduleType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeFlowScheduleType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeFlowScheduleType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFlowScheduleType";
  FIX::DerivativeFlowScheduleType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeFlowScheduleType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeFlowScheduleType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeFlowScheduleType *)new FIX::DerivativeFlowScheduleType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeFlowScheduleType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeFlowScheduleType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeFlowScheduleType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeFlowScheduleType.new", 
    "    DerivativeFlowScheduleType.new()\n"
    "    DerivativeFlowScheduleType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeFlowScheduleType(FIX::DerivativeFlowScheduleType *arg1) {
    delete arg1;
}

swig_class SwigClassFlexibleIndicator;

SWIGINTERN VALUE
_wrap_new_FlexibleIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FlexibleIndicator";
  FIX::FlexibleIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FlexibleIndicator *)new FIX::FlexibleIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FlexibleIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FlexibleIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FlexibleIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FlexibleIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlexibleIndicator";
  FIX::FlexibleIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::FlexibleIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::FlexibleIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::FlexibleIndicator *)new FIX::FlexibleIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FlexibleIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FlexibleIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FlexibleIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FlexibleIndicator.new", 
    "    FlexibleIndicator.new()\n"
    "    FlexibleIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FlexibleIndicator(FIX::FlexibleIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassNoExecInstRules;

SWIGINTERN VALUE
_wrap_new_NoExecInstRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoExecInstRules";
  FIX::NoExecInstRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoExecInstRules *)new FIX::NoExecInstRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoExecInstRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoExecInstRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoExecInstRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoExecInstRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExecInstRules";
  FIX::NoExecInstRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoExecInstRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoExecInstRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoExecInstRules *)new FIX::NoExecInstRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoExecInstRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoExecInstRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoExecInstRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoExecInstRules.new", 
    "    NoExecInstRules.new()\n"
    "    NoExecInstRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoExecInstRules(FIX::NoExecInstRules *arg1) {
    delete arg1;
}

swig_class SwigClassSideTrdRegTimestamp;

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestamp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestamp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::SideTrdRegTimestamp", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestamp__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::SideTrdRegTimestamp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::SideTrdRegTimestamp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideTrdRegTimestamp_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideTrdRegTimestamp_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideTrdRegTimestamp);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestamp__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::SideTrdRegTimestamp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::SideTrdRegTimestamp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::SideTrdRegTimestamp", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideTrdRegTimestamp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideTrdRegTimestamp__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdRegTimestamp__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SideTrdRegTimestamp__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SideTrdRegTimestamp__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SideTrdRegTimestamp.new", 
    "    SideTrdRegTimestamp.new()\n"
    "    SideTrdRegTimestamp.new(bool showMilliseconds)\n"
    "    SideTrdRegTimestamp.new(FIX::UTCTIMESTAMP const &value)\n"
    "    SideTrdRegTimestamp.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdRegTimestamp(FIX::SideTrdRegTimestamp *arg1) {
    delete arg1;
}

swig_class SwigClassDeliveryForm;

SWIGINTERN VALUE
_wrap_new_DeliveryForm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeliveryForm";
  FIX::DeliveryForm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeliveryForm *)new FIX::DeliveryForm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeliveryForm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeliveryForm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeliveryForm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeliveryForm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryForm";
  FIX::DeliveryForm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DeliveryForm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DeliveryForm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DeliveryForm *)new FIX::DeliveryForm((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeliveryForm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeliveryForm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliveryForm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeliveryForm.new", 
    "    DeliveryForm.new()\n"
    "    DeliveryForm.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliveryForm(FIX::DeliveryForm *arg1) {
    delete arg1;
}

swig_class SwigClassExecRestatementReason;

SWIGINTERN VALUE
_wrap_new_ExecRestatementReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecRestatementReason";
  FIX::ExecRestatementReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecRestatementReason *)new FIX::ExecRestatementReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecRestatementReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecRestatementReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecRestatementReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecRestatementReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecRestatementReason";
  FIX::ExecRestatementReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ExecRestatementReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ExecRestatementReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ExecRestatementReason *)new FIX::ExecRestatementReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecRestatementReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecRestatementReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecRestatementReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecRestatementReason.new", 
    "    ExecRestatementReason.new()\n"
    "    ExecRestatementReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecRestatementReason(FIX::ExecRestatementReason *arg1) {
    delete arg1;
}

swig_class SwigClassMidYield;

SWIGINTERN VALUE
_wrap_new_MidYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MidYield";
  FIX::MidYield *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MidYield *)new FIX::MidYield();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MidYield_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MidYield_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MidYield);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MidYield__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MidYield";
  FIX::MidYield *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::MidYield", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::MidYield", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::MidYield *)new FIX::MidYield((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MidYield(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MidYield__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MidYield__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MidYield.new", 
    "    MidYield.new()\n"
    "    MidYield.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MidYield(FIX::MidYield *arg1) {
    delete arg1;
}

swig_class SwigClassContractMultiplier;

SWIGINTERN VALUE
_wrap_new_ContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplier";
  FIX::ContractMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContractMultiplier *)new FIX::ContractMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContractMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContractMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContractMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContractMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplier";
  FIX::ContractMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::ContractMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::ContractMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::ContractMultiplier *)new FIX::ContractMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContractMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContractMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContractMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContractMultiplier.new", 
    "    ContractMultiplier.new()\n"
    "    ContractMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContractMultiplier(FIX::ContractMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassCcyAmt;

SWIGINTERN VALUE
_wrap_new_CcyAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CcyAmt";
  FIX::CcyAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CcyAmt *)new FIX::CcyAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CcyAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CcyAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CcyAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CcyAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CcyAmt";
  FIX::CcyAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::CcyAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::CcyAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::CcyAmt *)new FIX::CcyAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CcyAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CcyAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CcyAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CcyAmt.new", 
    "    CcyAmt.new()\n"
    "    CcyAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CcyAmt(FIX::CcyAmt *arg1) {
    delete arg1;
}

swig_class SwigClassLegOrderQty;

SWIGINTERN VALUE
_wrap_new_LegOrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegOrderQty";
  FIX::LegOrderQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegOrderQty *)new FIX::LegOrderQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegOrderQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegOrderQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegOrderQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegOrderQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOrderQty";
  FIX::LegOrderQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegOrderQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegOrderQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegOrderQty *)new FIX::LegOrderQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegOrderQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegOrderQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOrderQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegOrderQty.new", 
    "    LegOrderQty.new()\n"
    "    LegOrderQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOrderQty(FIX::LegOrderQty *arg1) {
    delete arg1;
}

swig_class SwigClassAllocIntermedReqType;

SWIGINTERN VALUE
_wrap_new_AllocIntermedReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocIntermedReqType";
  FIX::AllocIntermedReqType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocIntermedReqType *)new FIX::AllocIntermedReqType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocIntermedReqType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocIntermedReqType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocIntermedReqType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocIntermedReqType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocIntermedReqType";
  FIX::AllocIntermedReqType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocIntermedReqType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocIntermedReqType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocIntermedReqType *)new FIX::AllocIntermedReqType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocIntermedReqType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocIntermedReqType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocIntermedReqType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocIntermedReqType.new", 
    "    AllocIntermedReqType.new()\n"
    "    AllocIntermedReqType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocIntermedReqType(FIX::AllocIntermedReqType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingIssuer;

SWIGINTERN VALUE
_wrap_new_UnderlyingIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssuer";
  FIX::UnderlyingIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingIssuer *)new FIX::UnderlyingIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssuer";
  FIX::UnderlyingIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingIssuer *)new FIX::UnderlyingIssuer((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingIssuer.new", 
    "    UnderlyingIssuer.new()\n"
    "    UnderlyingIssuer.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingIssuer(FIX::UnderlyingIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassNoNested2PartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNested2PartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartyIDs";
  FIX::NoNested2PartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNested2PartyIDs *)new FIX::NoNested2PartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNested2PartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNested2PartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNested2PartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNested2PartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartyIDs";
  FIX::NoNested2PartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNested2PartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNested2PartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNested2PartyIDs *)new FIX::NoNested2PartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNested2PartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNested2PartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested2PartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNested2PartyIDs.new", 
    "    NoNested2PartyIDs.new()\n"
    "    NoNested2PartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested2PartyIDs(FIX::NoNested2PartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassMinTradeVol;

SWIGINTERN VALUE
_wrap_new_MinTradeVol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinTradeVol";
  FIX::MinTradeVol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinTradeVol *)new FIX::MinTradeVol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinTradeVol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinTradeVol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinTradeVol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinTradeVol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinTradeVol";
  FIX::MinTradeVol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MinTradeVol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MinTradeVol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MinTradeVol *)new FIX::MinTradeVol((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinTradeVol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinTradeVol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinTradeVol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinTradeVol.new", 
    "    MinTradeVol.new()\n"
    "    MinTradeVol.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinTradeVol(FIX::MinTradeVol *arg1) {
    delete arg1;
}

swig_class SwigClassSettlCurrAmt;

SWIGINTERN VALUE
_wrap_new_SettlCurrAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrAmt";
  FIX::SettlCurrAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlCurrAmt *)new FIX::SettlCurrAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlCurrAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlCurrAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlCurrAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlCurrAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrAmt";
  FIX::SettlCurrAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::SettlCurrAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::SettlCurrAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::SettlCurrAmt *)new FIX::SettlCurrAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlCurrAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlCurrAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlCurrAmt.new", 
    "    SettlCurrAmt.new()\n"
    "    SettlCurrAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrAmt(FIX::SettlCurrAmt *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyRole";
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrumentPartyRole *)new FIX::DerivativeInstrumentPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrumentPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrumentPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyRole";
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeInstrumentPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeInstrumentPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeInstrumentPartyRole *)new FIX::DerivativeInstrumentPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrumentPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrumentPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrumentPartyRole.new", 
    "    DerivativeInstrumentPartyRole.new()\n"
    "    DerivativeInstrumentPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartyRole(FIX::DerivativeInstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassYieldRedemptionPriceType;

SWIGINTERN VALUE
_wrap_new_YieldRedemptionPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPriceType";
  FIX::YieldRedemptionPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::YieldRedemptionPriceType *)new FIX::YieldRedemptionPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_YieldRedemptionPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_YieldRedemptionPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__YieldRedemptionPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_YieldRedemptionPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPriceType";
  FIX::YieldRedemptionPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::YieldRedemptionPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::YieldRedemptionPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::YieldRedemptionPriceType *)new FIX::YieldRedemptionPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_YieldRedemptionPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_YieldRedemptionPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldRedemptionPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "YieldRedemptionPriceType.new", 
    "    YieldRedemptionPriceType.new()\n"
    "    YieldRedemptionPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldRedemptionPriceType(FIX::YieldRedemptionPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassNewsRefID;

SWIGINTERN VALUE
_wrap_new_NewsRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NewsRefID";
  FIX::NewsRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NewsRefID *)new FIX::NewsRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NewsRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NewsRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NewsRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NewsRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsRefID";
  FIX::NewsRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NewsRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NewsRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NewsRefID *)new FIX::NewsRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NewsRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NewsRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NewsRefID.new", 
    "    NewsRefID.new()\n"
    "    NewsRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsRefID(FIX::NewsRefID *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityListTypeSource;

SWIGINTERN VALUE
_wrap_new_SecurityListTypeSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityListTypeSource";
  FIX::SecurityListTypeSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityListTypeSource *)new FIX::SecurityListTypeSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityListTypeSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityListTypeSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityListTypeSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityListTypeSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListTypeSource";
  FIX::SecurityListTypeSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityListTypeSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityListTypeSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityListTypeSource *)new FIX::SecurityListTypeSource((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityListTypeSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityListTypeSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListTypeSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityListTypeSource.new", 
    "    SecurityListTypeSource.new()\n"
    "    SecurityListTypeSource.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListTypeSource(FIX::SecurityListTypeSource *arg1) {
    delete arg1;
}

swig_class SwigClassApplReqID;

SWIGINTERN VALUE
_wrap_new_ApplReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplReqID";
  FIX::ApplReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplReqID *)new FIX::ApplReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReqID";
  FIX::ApplReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ApplReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ApplReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ApplReqID *)new FIX::ApplReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplReqID.new", 
    "    ApplReqID.new()\n"
    "    ApplReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReqID(FIX::ApplReqID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeFuturesValuationMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeFuturesValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFuturesValuationMethod";
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeFuturesValuationMethod *)new FIX::DerivativeFuturesValuationMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeFuturesValuationMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeFuturesValuationMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeFuturesValuationMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFuturesValuationMethod";
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeFuturesValuationMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeFuturesValuationMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeFuturesValuationMethod *)new FIX::DerivativeFuturesValuationMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeFuturesValuationMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeFuturesValuationMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeFuturesValuationMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeFuturesValuationMethod.new", 
    "    DerivativeFuturesValuationMethod.new()\n"
    "    DerivativeFuturesValuationMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeFuturesValuationMethod(FIX::DerivativeFuturesValuationMethod *arg1) {
    delete arg1;
}

swig_class SwigClassNoLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoLegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoLegSecurityAltID";
  FIX::NoLegSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoLegSecurityAltID *)new FIX::NoLegSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoLegSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoLegSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoLegSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoLegSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegSecurityAltID";
  FIX::NoLegSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoLegSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoLegSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoLegSecurityAltID *)new FIX::NoLegSecurityAltID((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoLegSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoLegSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoLegSecurityAltID.new", 
    "    NoLegSecurityAltID.new()\n"
    "    NoLegSecurityAltID.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegSecurityAltID(FIX::NoLegSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityType;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityType";
  FIX::DerivativeSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityType *)new FIX::DerivativeSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityType";
  FIX::DerivativeSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityType *)new FIX::DerivativeSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityType.new", 
    "    DerivativeSecurityType.new()\n"
    "    DerivativeSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityType(FIX::DerivativeSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassCollInquiryQualifier;

SWIGINTERN VALUE
_wrap_new_CollInquiryQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryQualifier";
  FIX::CollInquiryQualifier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollInquiryQualifier *)new FIX::CollInquiryQualifier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollInquiryQualifier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollInquiryQualifier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollInquiryQualifier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollInquiryQualifier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryQualifier";
  FIX::CollInquiryQualifier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollInquiryQualifier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollInquiryQualifier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollInquiryQualifier *)new FIX::CollInquiryQualifier((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollInquiryQualifier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollInquiryQualifier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryQualifier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollInquiryQualifier.new", 
    "    CollInquiryQualifier.new()\n"
    "    CollInquiryQualifier.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryQualifier(FIX::CollInquiryQualifier *arg1) {
    delete arg1;
}

swig_class SwigClassRawData;

SWIGINTERN VALUE
_wrap_new_RawData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RawData";
  FIX::RawData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RawData *)new FIX::RawData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RawData_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RawData_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RawData);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RawData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RawData";
  FIX::RawData *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::RawData", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::RawData", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::RawData *)new FIX::RawData((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RawData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RawData__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawData__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RawData.new", 
    "    RawData.new()\n"
    "    RawData.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RawData(FIX::RawData *arg1) {
    delete arg1;
}

swig_class SwigClassCashSettlAgentContactPhone;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentContactPhone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactPhone";
  FIX::CashSettlAgentContactPhone *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashSettlAgentContactPhone *)new FIX::CashSettlAgentContactPhone();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashSettlAgentContactPhone_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashSettlAgentContactPhone_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashSettlAgentContactPhone);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashSettlAgentContactPhone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactPhone";
  FIX::CashSettlAgentContactPhone *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashSettlAgentContactPhone", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashSettlAgentContactPhone", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashSettlAgentContactPhone *)new FIX::CashSettlAgentContactPhone((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashSettlAgentContactPhone(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashSettlAgentContactPhone__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentContactPhone__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashSettlAgentContactPhone.new", 
    "    CashSettlAgentContactPhone.new()\n"
    "    CashSettlAgentContactPhone.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentContactPhone(FIX::CashSettlAgentContactPhone *arg1) {
    delete arg1;
}

swig_class SwigClassCreditRating;

SWIGINTERN VALUE
_wrap_new_CreditRating__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CreditRating";
  FIX::CreditRating *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CreditRating *)new FIX::CreditRating();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CreditRating_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CreditRating_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CreditRating);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CreditRating__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CreditRating";
  FIX::CreditRating *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CreditRating", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CreditRating", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CreditRating *)new FIX::CreditRating((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CreditRating(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CreditRating__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CreditRating__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CreditRating.new", 
    "    CreditRating.new()\n"
    "    CreditRating.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CreditRating(FIX::CreditRating *arg1) {
    delete arg1;
}

swig_class SwigClassContingencyType;

SWIGINTERN VALUE
_wrap_new_ContingencyType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContingencyType";
  FIX::ContingencyType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContingencyType *)new FIX::ContingencyType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContingencyType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContingencyType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContingencyType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContingencyType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContingencyType";
  FIX::ContingencyType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ContingencyType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ContingencyType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ContingencyType *)new FIX::ContingencyType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContingencyType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContingencyType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContingencyType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContingencyType.new", 
    "    ContingencyType.new()\n"
    "    ContingencyType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContingencyType(FIX::ContingencyType *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_StrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeCurrency";
  FIX::StrikeCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeCurrency *)new FIX::StrikeCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeCurrency";
  FIX::StrikeCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::StrikeCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::StrikeCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::StrikeCurrency *)new FIX::StrikeCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikeCurrency.new", 
    "    StrikeCurrency.new()\n"
    "    StrikeCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeCurrency(FIX::StrikeCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassTradeVolume;

SWIGINTERN VALUE
_wrap_new_TradeVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeVolume";
  FIX::TradeVolume *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeVolume *)new FIX::TradeVolume();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeVolume_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeVolume_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeVolume);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeVolume__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeVolume";
  FIX::TradeVolume *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::TradeVolume", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::TradeVolume", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::TradeVolume *)new FIX::TradeVolume((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeVolume(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeVolume__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeVolume__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeVolume.new", 
    "    TradeVolume.new()\n"
    "    TradeVolume.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeVolume(FIX::TradeVolume *arg1) {
    delete arg1;
}

swig_class SwigClassSideTrdRegTimestampSrc;

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestampSrc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampSrc";
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideTrdRegTimestampSrc *)new FIX::SideTrdRegTimestampSrc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideTrdRegTimestampSrc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideTrdRegTimestampSrc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideTrdRegTimestampSrc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestampSrc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampSrc";
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SideTrdRegTimestampSrc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SideTrdRegTimestampSrc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SideTrdRegTimestampSrc *)new FIX::SideTrdRegTimestampSrc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideTrdRegTimestampSrc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideTrdRegTimestampSrc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdRegTimestampSrc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideTrdRegTimestampSrc.new", 
    "    SideTrdRegTimestampSrc.new()\n"
    "    SideTrdRegTimestampSrc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdRegTimestampSrc(FIX::SideTrdRegTimestampSrc *arg1) {
    delete arg1;
}

swig_class SwigClassDeliveryDate;

SWIGINTERN VALUE
_wrap_new_DeliveryDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeliveryDate";
  FIX::DeliveryDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeliveryDate *)new FIX::DeliveryDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeliveryDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeliveryDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeliveryDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeliveryDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryDate";
  FIX::DeliveryDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::DeliveryDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::DeliveryDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::DeliveryDate *)new FIX::DeliveryDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeliveryDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeliveryDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliveryDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeliveryDate.new", 
    "    DeliveryDate.new()\n"
    "    DeliveryDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliveryDate(FIX::DeliveryDate *arg1) {
    delete arg1;
}

swig_class SwigClassEmailType;

SWIGINTERN VALUE
_wrap_new_EmailType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EmailType";
  FIX::EmailType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EmailType *)new FIX::EmailType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EmailType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EmailType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EmailType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EmailType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EmailType";
  FIX::EmailType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::EmailType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::EmailType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::EmailType *)new FIX::EmailType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EmailType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EmailType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EmailType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EmailType.new", 
    "    EmailType.new()\n"
    "    EmailType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EmailType(FIX::EmailType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedListExecInst;

SWIGINTERN VALUE
_wrap_new_EncodedListExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInst";
  FIX::EncodedListExecInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedListExecInst *)new FIX::EncodedListExecInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedListExecInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedListExecInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedListExecInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedListExecInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInst";
  FIX::EncodedListExecInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedListExecInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedListExecInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedListExecInst *)new FIX::EncodedListExecInst((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedListExecInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedListExecInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListExecInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedListExecInst.new", 
    "    EncodedListExecInst.new()\n"
    "    EncodedListExecInst.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListExecInst(FIX::EncodedListExecInst *arg1) {
    delete arg1;
}

swig_class SwigClassContraTradeTime;

SWIGINTERN VALUE
_wrap_new_ContraTradeTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  FIX::ContraTradeTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ContraTradeTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  FIX::ContraTradeTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ContraTradeTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ContraTradeTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  FIX::ContraTradeTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ContraTradeTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ContraTradeTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContraTradeTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContraTradeTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContraTradeTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContraTradeTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  FIX::ContraTradeTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ContraTradeTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ContraTradeTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ContraTradeTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContraTradeTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContraTradeTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraTradeTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ContraTradeTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ContraTradeTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ContraTradeTime.new", 
    "    ContraTradeTime.new()\n"
    "    ContraTradeTime.new(bool showMilliseconds)\n"
    "    ContraTradeTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    ContraTradeTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraTradeTime(FIX::ContraTradeTime *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityMonthYearIncrement;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrement";
  FIX::MaturityMonthYearIncrement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityMonthYearIncrement *)new FIX::MaturityMonthYearIncrement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityMonthYearIncrement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityMonthYearIncrement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityMonthYearIncrement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearIncrement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrement";
  FIX::MaturityMonthYearIncrement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MaturityMonthYearIncrement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MaturityMonthYearIncrement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MaturityMonthYearIncrement *)new FIX::MaturityMonthYearIncrement((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityMonthYearIncrement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityMonthYearIncrement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYearIncrement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityMonthYearIncrement.new", 
    "    MaturityMonthYearIncrement.new()\n"
    "    MaturityMonthYearIncrement.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYearIncrement(FIX::MaturityMonthYearIncrement *arg1) {
    delete arg1;
}

swig_class SwigClassRootPartyIDSource;

SWIGINTERN VALUE
_wrap_new_RootPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RootPartyIDSource";
  FIX::RootPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RootPartyIDSource *)new FIX::RootPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RootPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RootPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RootPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RootPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyIDSource";
  FIX::RootPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::RootPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::RootPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RootPartyIDSource *)new FIX::RootPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RootPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RootPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RootPartyIDSource.new", 
    "    RootPartyIDSource.new()\n"
    "    RootPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartyIDSource(FIX::RootPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCouponPaymentDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingCouponPaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponPaymentDate";
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCouponPaymentDate *)new FIX::UnderlyingCouponPaymentDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCouponPaymentDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCouponPaymentDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCouponPaymentDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponPaymentDate";
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::UnderlyingCouponPaymentDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::UnderlyingCouponPaymentDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::UnderlyingCouponPaymentDate *)new FIX::UnderlyingCouponPaymentDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCouponPaymentDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCouponPaymentDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCouponPaymentDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCouponPaymentDate.new", 
    "    UnderlyingCouponPaymentDate.new()\n"
    "    UnderlyingCouponPaymentDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCouponPaymentDate(FIX::UnderlyingCouponPaymentDate *arg1) {
    delete arg1;
}

swig_class SwigClassBidYield;

SWIGINTERN VALUE
_wrap_new_BidYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidYield";
  FIX::BidYield *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidYield *)new FIX::BidYield();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidYield_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidYield_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidYield);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidYield__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidYield";
  FIX::BidYield *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::BidYield", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::BidYield", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::BidYield *)new FIX::BidYield((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidYield(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidYield__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidYield__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidYield.new", 
    "    BidYield.new()\n"
    "    BidYield.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidYield(FIX::BidYield *arg1) {
    delete arg1;
}

swig_class SwigClassIOIQltyInd;

SWIGINTERN VALUE
_wrap_new_IOIQltyInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIQltyInd";
  FIX::IOIQltyInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIQltyInd *)new FIX::IOIQltyInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIQltyInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIQltyInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIQltyInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIQltyInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQltyInd";
  FIX::IOIQltyInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::IOIQltyInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::IOIQltyInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::IOIQltyInd *)new FIX::IOIQltyInd((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIQltyInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIQltyInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIQltyInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIQltyInd.new", 
    "    IOIQltyInd.new()\n"
    "    IOIQltyInd.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIQltyInd(FIX::IOIQltyInd *arg1) {
    delete arg1;
}

swig_class SwigClassIssuer;

SWIGINTERN VALUE
_wrap_new_Issuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Issuer";
  FIX::Issuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Issuer *)new FIX::Issuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Issuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Issuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Issuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Issuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Issuer";
  FIX::Issuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Issuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Issuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Issuer *)new FIX::Issuer((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Issuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Issuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Issuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Issuer.new", 
    "    Issuer.new()\n"
    "    Issuer.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Issuer(FIX::Issuer *arg1) {
    delete arg1;
}

swig_class SwigClassCardNumber;

SWIGINTERN VALUE
_wrap_new_CardNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CardNumber";
  FIX::CardNumber *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CardNumber *)new FIX::CardNumber();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CardNumber_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CardNumber_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CardNumber);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CardNumber__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardNumber";
  FIX::CardNumber *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CardNumber", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CardNumber", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CardNumber *)new FIX::CardNumber((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CardNumber(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CardNumber__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardNumber__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CardNumber.new", 
    "    CardNumber.new()\n"
    "    CardNumber.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CardNumber(FIX::CardNumber *arg1) {
    delete arg1;
}

swig_class SwigClassNoLegStipulations;

SWIGINTERN VALUE
_wrap_new_NoLegStipulations__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoLegStipulations";
  FIX::NoLegStipulations *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoLegStipulations *)new FIX::NoLegStipulations();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoLegStipulations_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoLegStipulations_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoLegStipulations);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoLegStipulations__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegStipulations";
  FIX::NoLegStipulations *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoLegStipulations", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoLegStipulations", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoLegStipulations *)new FIX::NoLegStipulations((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoLegStipulations(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoLegStipulations__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegStipulations__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoLegStipulations.new", 
    "    NoLegStipulations.new()\n"
    "    NoLegStipulations.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegStipulations(FIX::NoLegStipulations *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityExchange;

SWIGINTERN VALUE
_wrap_new_LegSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityExchange";
  FIX::LegSecurityExchange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityExchange *)new FIX::LegSecurityExchange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityExchange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityExchange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityExchange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityExchange";
  FIX::LegSecurityExchange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::LegSecurityExchange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::LegSecurityExchange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::LegSecurityExchange *)new FIX::LegSecurityExchange((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityExchange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityExchange.new", 
    "    LegSecurityExchange.new()\n"
    "    LegSecurityExchange.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityExchange(FIX::LegSecurityExchange *arg1) {
    delete arg1;
}

swig_class SwigClassCashOrderQty;

SWIGINTERN VALUE
_wrap_new_CashOrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashOrderQty";
  FIX::CashOrderQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashOrderQty *)new FIX::CashOrderQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashOrderQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashOrderQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashOrderQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashOrderQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashOrderQty";
  FIX::CashOrderQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::CashOrderQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::CashOrderQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::CashOrderQty *)new FIX::CashOrderQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashOrderQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashOrderQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashOrderQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashOrderQty.new", 
    "    CashOrderQty.new()\n"
    "    CashOrderQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashOrderQty(FIX::CashOrderQty *arg1) {
    delete arg1;
}

swig_class SwigClassAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_AccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestAmt";
  FIX::AccruedInterestAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AccruedInterestAmt *)new FIX::AccruedInterestAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AccruedInterestAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AccruedInterestAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AccruedInterestAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AccruedInterestAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestAmt";
  FIX::AccruedInterestAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::AccruedInterestAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::AccruedInterestAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::AccruedInterestAmt *)new FIX::AccruedInterestAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AccruedInterestAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AccruedInterestAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccruedInterestAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AccruedInterestAmt.new", 
    "    AccruedInterestAmt.new()\n"
    "    AccruedInterestAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AccruedInterestAmt(FIX::AccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntrySeller;

SWIGINTERN VALUE
_wrap_new_MDEntrySeller__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySeller";
  FIX::MDEntrySeller *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntrySeller *)new FIX::MDEntrySeller();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntrySeller_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntrySeller_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntrySeller);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntrySeller__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySeller";
  FIX::MDEntrySeller *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDEntrySeller", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDEntrySeller", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDEntrySeller *)new FIX::MDEntrySeller((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntrySeller(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntrySeller__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntrySeller__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntrySeller.new", 
    "    MDEntrySeller.new()\n"
    "    MDEntrySeller.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntrySeller(FIX::MDEntrySeller *arg1) {
    delete arg1;
}

swig_class SwigClassLegPrice;

SWIGINTERN VALUE
_wrap_new_LegPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPrice";
  FIX::LegPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPrice *)new FIX::LegPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPrice";
  FIX::LegPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LegPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LegPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LegPrice *)new FIX::LegPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPrice.new", 
    "    LegPrice.new()\n"
    "    LegPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPrice(FIX::LegPrice *arg1) {
    delete arg1;
}

swig_class SwigClassDeliverToCompID;

SWIGINTERN VALUE
_wrap_new_DeliverToCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeliverToCompID";
  FIX::DeliverToCompID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeliverToCompID *)new FIX::DeliverToCompID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeliverToCompID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeliverToCompID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeliverToCompID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeliverToCompID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToCompID";
  FIX::DeliverToCompID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DeliverToCompID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DeliverToCompID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DeliverToCompID *)new FIX::DeliverToCompID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeliverToCompID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeliverToCompID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliverToCompID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeliverToCompID.new", 
    "    DeliverToCompID.new()\n"
    "    DeliverToCompID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliverToCompID(FIX::DeliverToCompID *arg1) {
    delete arg1;
}

swig_class SwigClassTargetLocationID;

SWIGINTERN VALUE
_wrap_new_TargetLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetLocationID";
  FIX::TargetLocationID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetLocationID *)new FIX::TargetLocationID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetLocationID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetLocationID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetLocationID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetLocationID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetLocationID";
  FIX::TargetLocationID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TargetLocationID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TargetLocationID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TargetLocationID *)new FIX::TargetLocationID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetLocationID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetLocationID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetLocationID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetLocationID.new", 
    "    TargetLocationID.new()\n"
    "    TargetLocationID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetLocationID(FIX::TargetLocationID *arg1) {
    delete arg1;
}

swig_class SwigClassOfferForwardPoints2;

SWIGINTERN VALUE
_wrap_new_OfferForwardPoints2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints2";
  FIX::OfferForwardPoints2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferForwardPoints2 *)new FIX::OfferForwardPoints2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferForwardPoints2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferForwardPoints2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferForwardPoints2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferForwardPoints2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints2";
  FIX::OfferForwardPoints2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::OfferForwardPoints2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::OfferForwardPoints2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::OfferForwardPoints2 *)new FIX::OfferForwardPoints2((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferForwardPoints2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferForwardPoints2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferForwardPoints2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferForwardPoints2.new", 
    "    OfferForwardPoints2.new()\n"
    "    OfferForwardPoints2.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferForwardPoints2(FIX::OfferForwardPoints2 *arg1) {
    delete arg1;
}

swig_class SwigClassRatioQty;

SWIGINTERN VALUE
_wrap_new_RatioQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RatioQty";
  FIX::RatioQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RatioQty *)new FIX::RatioQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RatioQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RatioQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RatioQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RatioQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RatioQty";
  FIX::RatioQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::RatioQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::RatioQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::RatioQty *)new FIX::RatioQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RatioQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RatioQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RatioQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RatioQty.new", 
    "    RatioQty.new()\n"
    "    RatioQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RatioQty(FIX::RatioQty *arg1) {
    delete arg1;
}

swig_class SwigClassMultiLegRptTypeReq;

SWIGINTERN VALUE
_wrap_new_MultiLegRptTypeReq__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MultiLegRptTypeReq";
  FIX::MultiLegRptTypeReq *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MultiLegRptTypeReq *)new FIX::MultiLegRptTypeReq();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MultiLegRptTypeReq_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MultiLegRptTypeReq_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MultiLegRptTypeReq);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MultiLegRptTypeReq__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultiLegRptTypeReq";
  FIX::MultiLegRptTypeReq *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MultiLegRptTypeReq", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MultiLegRptTypeReq", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MultiLegRptTypeReq *)new FIX::MultiLegRptTypeReq((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MultiLegRptTypeReq(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MultiLegRptTypeReq__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultiLegRptTypeReq__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MultiLegRptTypeReq.new", 
    "    MultiLegRptTypeReq.new()\n"
    "    MultiLegRptTypeReq.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MultiLegRptTypeReq(FIX::MultiLegRptTypeReq *arg1) {
    delete arg1;
}

swig_class SwigClassAllocAccount;

SWIGINTERN VALUE
_wrap_new_AllocAccount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocAccount";
  FIX::AllocAccount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocAccount *)new FIX::AllocAccount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocAccount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocAccount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocAccount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocAccount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccount";
  FIX::AllocAccount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocAccount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocAccount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocAccount *)new FIX::AllocAccount((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocAccount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocAccount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAccount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocAccount.new", 
    "    AllocAccount.new()\n"
    "    AllocAccount.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAccount(FIX::AllocAccount *arg1) {
    delete arg1;
}

swig_class SwigClassTotalVolumeTraded;

SWIGINTERN VALUE
_wrap_new_TotalVolumeTraded__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTraded";
  FIX::TotalVolumeTraded *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalVolumeTraded *)new FIX::TotalVolumeTraded();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalVolumeTraded_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalVolumeTraded_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalVolumeTraded);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalVolumeTraded__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTraded";
  FIX::TotalVolumeTraded *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::TotalVolumeTraded", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::TotalVolumeTraded", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::TotalVolumeTraded *)new FIX::TotalVolumeTraded((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalVolumeTraded(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalVolumeTraded__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTraded__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalVolumeTraded.new", 
    "    TotalVolumeTraded.new()\n"
    "    TotalVolumeTraded.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalVolumeTraded(FIX::TotalVolumeTraded *arg1) {
    delete arg1;
}

swig_class SwigClassLinesOfText;

SWIGINTERN VALUE
_wrap_new_LinesOfText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LinesOfText";
  FIX::LinesOfText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LinesOfText *)new FIX::LinesOfText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LinesOfText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LinesOfText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LinesOfText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LinesOfText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LinesOfText";
  FIX::LinesOfText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::LinesOfText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::LinesOfText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::LinesOfText *)new FIX::LinesOfText((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LinesOfText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LinesOfText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinesOfText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LinesOfText.new", 
    "    LinesOfText.new()\n"
    "    LinesOfText.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LinesOfText(FIX::LinesOfText *arg1) {
    delete arg1;
}

swig_class SwigClassAccountType;

SWIGINTERN VALUE
_wrap_new_AccountType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AccountType";
  FIX::AccountType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AccountType *)new FIX::AccountType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AccountType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AccountType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AccountType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AccountType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccountType";
  FIX::AccountType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AccountType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AccountType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AccountType *)new FIX::AccountType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AccountType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AccountType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccountType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AccountType.new", 
    "    AccountType.new()\n"
    "    AccountType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AccountType(FIX::AccountType *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryPositionNo;

SWIGINTERN VALUE
_wrap_new_MDEntryPositionNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPositionNo";
  FIX::MDEntryPositionNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryPositionNo *)new FIX::MDEntryPositionNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryPositionNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryPositionNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryPositionNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryPositionNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPositionNo";
  FIX::MDEntryPositionNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDEntryPositionNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDEntryPositionNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDEntryPositionNo *)new FIX::MDEntryPositionNo((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryPositionNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryPositionNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryPositionNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryPositionNo.new", 
    "    MDEntryPositionNo.new()\n"
    "    MDEntryPositionNo.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryPositionNo(FIX::MDEntryPositionNo *arg1) {
    delete arg1;
}

swig_class SwigClassHaltReasonInt;

SWIGINTERN VALUE
_wrap_new_HaltReasonInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonInt";
  FIX::HaltReasonInt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HaltReasonInt *)new FIX::HaltReasonInt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HaltReasonInt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HaltReasonInt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HaltReasonInt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HaltReasonInt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonInt";
  FIX::HaltReasonInt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::HaltReasonInt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::HaltReasonInt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::HaltReasonInt *)new FIX::HaltReasonInt((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HaltReasonInt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HaltReasonInt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HaltReasonInt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HaltReasonInt.new", 
    "    HaltReasonInt.new()\n"
    "    HaltReasonInt.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HaltReasonInt(FIX::HaltReasonInt *arg1) {
    delete arg1;
}

swig_class SwigClassFutSettDate;

SWIGINTERN VALUE
_wrap_new_FutSettDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate";
  FIX::FutSettDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FutSettDate *)new FIX::FutSettDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FutSettDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FutSettDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FutSettDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FutSettDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate";
  FIX::FutSettDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::FutSettDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::FutSettDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::FutSettDate *)new FIX::FutSettDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FutSettDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FutSettDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FutSettDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FutSettDate.new", 
    "    FutSettDate.new()\n"
    "    FutSettDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FutSettDate(FIX::FutSettDate *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityDesc;

SWIGINTERN VALUE
_wrap_new_SecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityDesc";
  FIX::SecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityDesc *)new FIX::SecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityDesc";
  FIX::SecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityDesc *)new FIX::SecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityDesc.new", 
    "    SecurityDesc.new()\n"
    "    SecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityDesc(FIX::SecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassMinQty;

SWIGINTERN VALUE
_wrap_new_MinQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinQty";
  FIX::MinQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinQty *)new FIX::MinQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinQty";
  FIX::MinQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MinQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MinQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MinQty *)new FIX::MinQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinQty.new", 
    "    MinQty.new()\n"
    "    MinQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinQty(FIX::MinQty *arg1) {
    delete arg1;
}

swig_class SwigClassSettlCurrency;

SWIGINTERN VALUE
_wrap_new_SettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrency";
  FIX::SettlCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlCurrency *)new FIX::SettlCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrency";
  FIX::SettlCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::SettlCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::SettlCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::SettlCurrency *)new FIX::SettlCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlCurrency.new", 
    "    SettlCurrency.new()\n"
    "    SettlCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrency(FIX::SettlCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassPegOffsetValue;

SWIGINTERN VALUE
_wrap_new_PegOffsetValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetValue";
  FIX::PegOffsetValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegOffsetValue *)new FIX::PegOffsetValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegOffsetValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegOffsetValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegOffsetValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegOffsetValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetValue";
  FIX::PegOffsetValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::PegOffsetValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::PegOffsetValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::PegOffsetValue *)new FIX::PegOffsetValue((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegOffsetValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegOffsetValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegOffsetValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegOffsetValue.new", 
    "    PegOffsetValue.new()\n"
    "    PegOffsetValue.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegOffsetValue(FIX::PegOffsetValue *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltIDSource";
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityAltIDSource *)new FIX::DerivativeSecurityAltIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityAltIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityAltIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltIDSource";
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityAltIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityAltIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityAltIDSource *)new FIX::DerivativeSecurityAltIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityAltIDSource.new", 
    "    DerivativeSecurityAltIDSource.new()\n"
    "    DerivativeSecurityAltIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityAltIDSource(FIX::DerivativeSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassNoSettlPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoSettlPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartySubIDs";
  FIX::NoSettlPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSettlPartySubIDs *)new FIX::NoSettlPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSettlPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSettlPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSettlPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSettlPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartySubIDs";
  FIX::NoSettlPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSettlPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSettlPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSettlPartySubIDs *)new FIX::NoSettlPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSettlPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSettlPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSettlPartySubIDs.new", 
    "    NoSettlPartySubIDs.new()\n"
    "    NoSettlPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlPartySubIDs(FIX::NoSettlPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassAllocReportID;

SWIGINTERN VALUE
_wrap_new_AllocReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocReportID";
  FIX::AllocReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocReportID *)new FIX::AllocReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportID";
  FIX::AllocReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocReportID *)new FIX::AllocReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocReportID.new", 
    "    AllocReportID.new()\n"
    "    AllocReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocReportID(FIX::AllocReportID *arg1) {
    delete arg1;
}

swig_class SwigClassLegCFICode;

SWIGINTERN VALUE
_wrap_new_LegCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCFICode";
  FIX::LegCFICode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCFICode *)new FIX::LegCFICode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCFICode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCFICode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCFICode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCFICode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCFICode";
  FIX::LegCFICode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegCFICode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegCFICode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegCFICode *)new FIX::LegCFICode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCFICode.new", 
    "    LegCFICode.new()\n"
    "    LegCFICode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCFICode(FIX::LegCFICode *arg1) {
    delete arg1;
}

swig_class SwigClassLegFutSettDate;

SWIGINTERN VALUE
_wrap_new_LegFutSettDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegFutSettDate";
  FIX::LegFutSettDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegFutSettDate *)new FIX::LegFutSettDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegFutSettDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegFutSettDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegFutSettDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegFutSettDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFutSettDate";
  FIX::LegFutSettDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegFutSettDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegFutSettDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegFutSettDate *)new FIX::LegFutSettDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegFutSettDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegFutSettDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegFutSettDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegFutSettDate.new", 
    "    LegFutSettDate.new()\n"
    "    LegFutSettDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegFutSettDate(FIX::LegFutSettDate *arg1) {
    delete arg1;
}

swig_class SwigClassLegBenchmarkCurveName;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurveName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveName";
  FIX::LegBenchmarkCurveName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBenchmarkCurveName *)new FIX::LegBenchmarkCurveName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBenchmarkCurveName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBenchmarkCurveName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBenchmarkCurveName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurveName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveName";
  FIX::LegBenchmarkCurveName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegBenchmarkCurveName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegBenchmarkCurveName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegBenchmarkCurveName *)new FIX::LegBenchmarkCurveName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBenchmarkCurveName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBenchmarkCurveName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkCurveName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBenchmarkCurveName.new", 
    "    LegBenchmarkCurveName.new()\n"
    "    LegBenchmarkCurveName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkCurveName(FIX::LegBenchmarkCurveName *arg1) {
    delete arg1;
}

swig_class SwigClassClearingFeeIndicator;

SWIGINTERN VALUE
_wrap_new_ClearingFeeIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClearingFeeIndicator";
  FIX::ClearingFeeIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClearingFeeIndicator *)new FIX::ClearingFeeIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClearingFeeIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClearingFeeIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClearingFeeIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingFeeIndicator";
  FIX::ClearingFeeIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClearingFeeIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClearingFeeIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClearingFeeIndicator *)new FIX::ClearingFeeIndicator((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClearingFeeIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClearingFeeIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingFeeIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClearingFeeIndicator.new", 
    "    ClearingFeeIndicator.new()\n"
    "    ClearingFeeIndicator.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingFeeIndicator(FIX::ClearingFeeIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassBrokerOfCredit;

SWIGINTERN VALUE
_wrap_new_BrokerOfCredit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BrokerOfCredit";
  FIX::BrokerOfCredit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BrokerOfCredit *)new FIX::BrokerOfCredit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BrokerOfCredit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BrokerOfCredit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BrokerOfCredit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BrokerOfCredit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BrokerOfCredit";
  FIX::BrokerOfCredit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BrokerOfCredit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BrokerOfCredit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BrokerOfCredit *)new FIX::BrokerOfCredit((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BrokerOfCredit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BrokerOfCredit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BrokerOfCredit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BrokerOfCredit.new", 
    "    BrokerOfCredit.new()\n"
    "    BrokerOfCredit.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BrokerOfCredit(FIX::BrokerOfCredit *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityListRefID;

SWIGINTERN VALUE
_wrap_new_SecurityListRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRefID";
  FIX::SecurityListRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityListRefID *)new FIX::SecurityListRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityListRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityListRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityListRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityListRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRefID";
  FIX::SecurityListRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityListRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityListRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityListRefID *)new FIX::SecurityListRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityListRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityListRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityListRefID.new", 
    "    SecurityListRefID.new()\n"
    "    SecurityListRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListRefID(FIX::SecurityListRefID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegMaturityTime;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityTime";
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegMaturityTime *)new FIX::UnderlyingLegMaturityTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegMaturityTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegMaturityTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegMaturityTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityTime";
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TZTIMEONLY const &","FIX::UnderlyingLegMaturityTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TZTIMEONLY const &","FIX::UnderlyingLegMaturityTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::UnderlyingLegMaturityTime *)new FIX::UnderlyingLegMaturityTime((FIX::TZTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegMaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegMaturityTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegMaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegMaturityTime.new", 
    "    UnderlyingLegMaturityTime.new()\n"
    "    UnderlyingLegMaturityTime.new(FIX::TZTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegMaturityTime(FIX::UnderlyingLegMaturityTime *arg1) {
    delete arg1;
}

swig_class SwigClassNestedPartySubIDType;

SWIGINTERN VALUE
_wrap_new_NestedPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubIDType";
  FIX::NestedPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedPartySubIDType *)new FIX::NestedPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubIDType";
  FIX::NestedPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NestedPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NestedPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NestedPartySubIDType *)new FIX::NestedPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedPartySubIDType.new", 
    "    NestedPartySubIDType.new()\n"
    "    NestedPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartySubIDType(FIX::NestedPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassBidType;

SWIGINTERN VALUE
_wrap_new_BidType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidType";
  FIX::BidType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidType *)new FIX::BidType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidType";
  FIX::BidType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::BidType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::BidType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::BidType *)new FIX::BidType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidType.new", 
    "    BidType.new()\n"
    "    BidType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidType(FIX::BidType *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryRefID;

SWIGINTERN VALUE
_wrap_new_MDEntryRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryRefID";
  FIX::MDEntryRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryRefID *)new FIX::MDEntryRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryRefID";
  FIX::MDEntryRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDEntryRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDEntryRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDEntryRefID *)new FIX::MDEntryRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryRefID.new", 
    "    MDEntryRefID.new()\n"
    "    MDEntryRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryRefID(FIX::MDEntryRefID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasureQty";
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingUnitOfMeasureQty *)new FIX::UnderlyingUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasureQty";
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::UnderlyingUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::UnderlyingUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::UnderlyingUnitOfMeasureQty *)new FIX::UnderlyingUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingUnitOfMeasureQty.new", 
    "    UnderlyingUnitOfMeasureQty.new()\n"
    "    UnderlyingUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingUnitOfMeasureQty(FIX::UnderlyingUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegMaturityDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityDate";
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegMaturityDate *)new FIX::UnderlyingLegMaturityDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegMaturityDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegMaturityDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegMaturityDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityDate";
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::UnderlyingLegMaturityDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::UnderlyingLegMaturityDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::UnderlyingLegMaturityDate *)new FIX::UnderlyingLegMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegMaturityDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegMaturityDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegMaturityDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegMaturityDate.new", 
    "    UnderlyingLegMaturityDate.new()\n"
    "    UnderlyingLegMaturityDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegMaturityDate(FIX::UnderlyingLegMaturityDate *arg1) {
    delete arg1;
}

swig_class SwigClassStartTickPriceRange;

SWIGINTERN VALUE
_wrap_new_StartTickPriceRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StartTickPriceRange";
  FIX::StartTickPriceRange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StartTickPriceRange *)new FIX::StartTickPriceRange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StartTickPriceRange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StartTickPriceRange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StartTickPriceRange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StartTickPriceRange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartTickPriceRange";
  FIX::StartTickPriceRange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::StartTickPriceRange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::StartTickPriceRange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::StartTickPriceRange *)new FIX::StartTickPriceRange((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StartTickPriceRange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StartTickPriceRange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartTickPriceRange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StartTickPriceRange.new", 
    "    StartTickPriceRange.new()\n"
    "    StartTickPriceRange.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StartTickPriceRange(FIX::StartTickPriceRange *arg1) {
    delete arg1;
}

swig_class SwigClassLegContractSettlMonth;

SWIGINTERN VALUE
_wrap_new_LegContractSettlMonth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegContractSettlMonth";
  FIX::LegContractSettlMonth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegContractSettlMonth *)new FIX::LegContractSettlMonth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegContractSettlMonth_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegContractSettlMonth_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegContractSettlMonth);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegContractSettlMonth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractSettlMonth";
  FIX::LegContractSettlMonth *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::LegContractSettlMonth", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::LegContractSettlMonth", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::LegContractSettlMonth *)new FIX::LegContractSettlMonth((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegContractSettlMonth(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegContractSettlMonth__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegContractSettlMonth__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegContractSettlMonth.new", 
    "    LegContractSettlMonth.new()\n"
    "    LegContractSettlMonth.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegContractSettlMonth(FIX::LegContractSettlMonth *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityDesc;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityDesc";
  FIX::UnderlyingSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityDesc *)new FIX::UnderlyingSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityDesc";
  FIX::UnderlyingSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecurityDesc *)new FIX::UnderlyingSecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityDesc.new", 
    "    UnderlyingSecurityDesc.new()\n"
    "    UnderlyingSecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityDesc(FIX::UnderlyingSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassCashDistribPayRef;

SWIGINTERN VALUE
_wrap_new_CashDistribPayRef__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashDistribPayRef";
  FIX::CashDistribPayRef *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashDistribPayRef *)new FIX::CashDistribPayRef();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashDistribPayRef_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashDistribPayRef_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashDistribPayRef);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashDistribPayRef__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribPayRef";
  FIX::CashDistribPayRef *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashDistribPayRef", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashDistribPayRef", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashDistribPayRef *)new FIX::CashDistribPayRef((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashDistribPayRef(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashDistribPayRef__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribPayRef__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashDistribPayRef.new", 
    "    CashDistribPayRef.new()\n"
    "    CashDistribPayRef.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribPayRef(FIX::CashDistribPayRef *arg1) {
    delete arg1;
}

swig_class SwigClassQuotePriceType;

SWIGINTERN VALUE
_wrap_new_QuotePriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuotePriceType";
  FIX::QuotePriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuotePriceType *)new FIX::QuotePriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuotePriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuotePriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuotePriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuotePriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuotePriceType";
  FIX::QuotePriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuotePriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuotePriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuotePriceType *)new FIX::QuotePriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuotePriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuotePriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuotePriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuotePriceType.new", 
    "    QuotePriceType.new()\n"
    "    QuotePriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuotePriceType(FIX::QuotePriceType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedAllocText;

SWIGINTERN VALUE
_wrap_new_EncodedAllocText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocText";
  FIX::EncodedAllocText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedAllocText *)new FIX::EncodedAllocText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedAllocText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedAllocText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedAllocText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedAllocText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocText";
  FIX::EncodedAllocText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedAllocText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedAllocText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedAllocText *)new FIX::EncodedAllocText((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedAllocText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedAllocText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedAllocText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedAllocText.new", 
    "    EncodedAllocText.new()\n"
    "    EncodedAllocText.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedAllocText(FIX::EncodedAllocText *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityMonthYear";
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingMaturityMonthYear *)new FIX::UnderlyingMaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingMaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingMaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityMonthYear";
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::UnderlyingMaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::UnderlyingMaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::UnderlyingMaturityMonthYear *)new FIX::UnderlyingMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingMaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingMaturityMonthYear.new", 
    "    UnderlyingMaturityMonthYear.new()\n"
    "    UnderlyingMaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityMonthYear(FIX::UnderlyingMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingOriginalNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOriginalNotionalPercentageOutstanding";
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingOriginalNotionalPercentageOutstanding *)new FIX::UnderlyingOriginalNotionalPercentageOutstanding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingOriginalNotionalPercentageOutstanding_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingOriginalNotionalPercentageOutstanding_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOriginalNotionalPercentageOutstanding";
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingOriginalNotionalPercentageOutstanding", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingOriginalNotionalPercentageOutstanding", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingOriginalNotionalPercentageOutstanding *)new FIX::UnderlyingOriginalNotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingOriginalNotionalPercentageOutstanding(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingOriginalNotionalPercentageOutstanding.new", 
    "    UnderlyingOriginalNotionalPercentageOutstanding.new()\n"
    "    UnderlyingOriginalNotionalPercentageOutstanding.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingOriginalNotionalPercentageOutstanding(FIX::UnderlyingOriginalNotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class SwigClassMultilegPriceMethod;

SWIGINTERN VALUE
_wrap_new_MultilegPriceMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MultilegPriceMethod";
  FIX::MultilegPriceMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MultilegPriceMethod *)new FIX::MultilegPriceMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MultilegPriceMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MultilegPriceMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MultilegPriceMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MultilegPriceMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultilegPriceMethod";
  FIX::MultilegPriceMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MultilegPriceMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MultilegPriceMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MultilegPriceMethod *)new FIX::MultilegPriceMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MultilegPriceMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MultilegPriceMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultilegPriceMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MultilegPriceMethod.new", 
    "    MultilegPriceMethod.new()\n"
    "    MultilegPriceMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MultilegPriceMethod(FIX::MultilegPriceMethod *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoFills;

SWIGINTERN VALUE
_wrap_new_TotNoFills__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoFills";
  FIX::TotNoFills *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoFills *)new FIX::TotNoFills();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoFills_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoFills_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoFills);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoFills__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoFills";
  FIX::TotNoFills *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoFills", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoFills", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoFills *)new FIX::TotNoFills((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoFills(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoFills__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoFills__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoFills.new", 
    "    TotNoFills.new()\n"
    "    TotNoFills.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoFills(FIX::TotNoFills *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSettleOnOpenFlag;

SWIGINTERN VALUE
_wrap_new_DerivativeSettleOnOpenFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettleOnOpenFlag";
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSettleOnOpenFlag *)new FIX::DerivativeSettleOnOpenFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSettleOnOpenFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSettleOnOpenFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSettleOnOpenFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettleOnOpenFlag";
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSettleOnOpenFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSettleOnOpenFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSettleOnOpenFlag *)new FIX::DerivativeSettleOnOpenFlag((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSettleOnOpenFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSettleOnOpenFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSettleOnOpenFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSettleOnOpenFlag.new", 
    "    DerivativeSettleOnOpenFlag.new()\n"
    "    DerivativeSettleOnOpenFlag.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSettleOnOpenFlag(FIX::DerivativeSettleOnOpenFlag *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingRepurchaseTerm;

SWIGINTERN VALUE
_wrap_new_UnderlyingRepurchaseTerm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseTerm";
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingRepurchaseTerm *)new FIX::UnderlyingRepurchaseTerm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingRepurchaseTerm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingRepurchaseTerm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingRepurchaseTerm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseTerm";
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingRepurchaseTerm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingRepurchaseTerm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingRepurchaseTerm *)new FIX::UnderlyingRepurchaseTerm((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingRepurchaseTerm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingRepurchaseTerm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepurchaseTerm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingRepurchaseTerm.new", 
    "    UnderlyingRepurchaseTerm.new()\n"
    "    UnderlyingRepurchaseTerm.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRepurchaseTerm(FIX::UnderlyingRepurchaseTerm *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_DerivativeCountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCountryOfIssue";
  FIX::DerivativeCountryOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeCountryOfIssue *)new FIX::DerivativeCountryOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeCountryOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeCountryOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeCountryOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeCountryOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCountryOfIssue";
  FIX::DerivativeCountryOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__COUNTRY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::COUNTRY const &","FIX::DerivativeCountryOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::COUNTRY const &","FIX::DerivativeCountryOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  result = (FIX::DerivativeCountryOfIssue *)new FIX::DerivativeCountryOfIssue((FIX::COUNTRY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeCountryOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeCountryOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeCountryOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeCountryOfIssue.new", 
    "    DerivativeCountryOfIssue.new()\n"
    "    DerivativeCountryOfIssue.new(FIX::COUNTRY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeCountryOfIssue(FIX::DerivativeCountryOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassListMethod;

SWIGINTERN VALUE
_wrap_new_ListMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListMethod";
  FIX::ListMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListMethod *)new FIX::ListMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListMethod";
  FIX::ListMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ListMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ListMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ListMethod *)new FIX::ListMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListMethod.new", 
    "    ListMethod.new()\n"
    "    ListMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListMethod(FIX::ListMethod *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCPProgram;

SWIGINTERN VALUE
_wrap_new_UnderlyingCPProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPProgram";
  FIX::UnderlyingCPProgram *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCPProgram *)new FIX::UnderlyingCPProgram();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCPProgram_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCPProgram_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCPProgram);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCPProgram__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPProgram";
  FIX::UnderlyingCPProgram *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingCPProgram", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingCPProgram", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingCPProgram *)new FIX::UnderlyingCPProgram((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCPProgram(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCPProgram__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCPProgram__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCPProgram.new", 
    "    UnderlyingCPProgram.new()\n"
    "    UnderlyingCPProgram.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCPProgram(FIX::UnderlyingCPProgram *arg1) {
    delete arg1;
}

swig_class SwigClassPriceDelta;

SWIGINTERN VALUE
_wrap_new_PriceDelta__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceDelta";
  FIX::PriceDelta *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceDelta *)new FIX::PriceDelta();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceDelta_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceDelta_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceDelta);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceDelta__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceDelta";
  FIX::PriceDelta *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::PriceDelta", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::PriceDelta", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::PriceDelta *)new FIX::PriceDelta((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceDelta(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceDelta__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceDelta__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceDelta.new", 
    "    PriceDelta.new()\n"
    "    PriceDelta.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceDelta(FIX::PriceDelta *arg1) {
    delete arg1;
}

swig_class SwigClassRefSeqNum;

SWIGINTERN VALUE
_wrap_new_RefSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefSeqNum";
  FIX::RefSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefSeqNum *)new FIX::RefSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefSeqNum";
  FIX::RefSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::RefSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::RefSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::RefSeqNum *)new FIX::RefSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefSeqNum.new", 
    "    RefSeqNum.new()\n"
    "    RefSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefSeqNum(FIX::RefSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassAutoAcceptIndicator;

SWIGINTERN VALUE
_wrap_new_AutoAcceptIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AutoAcceptIndicator";
  FIX::AutoAcceptIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AutoAcceptIndicator *)new FIX::AutoAcceptIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AutoAcceptIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AutoAcceptIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AutoAcceptIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AutoAcceptIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AutoAcceptIndicator";
  FIX::AutoAcceptIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::AutoAcceptIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::AutoAcceptIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::AutoAcceptIndicator *)new FIX::AutoAcceptIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AutoAcceptIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AutoAcceptIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AutoAcceptIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AutoAcceptIndicator.new", 
    "    AutoAcceptIndicator.new()\n"
    "    AutoAcceptIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AutoAcceptIndicator(FIX::AutoAcceptIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassMDImplicitDelete;

SWIGINTERN VALUE
_wrap_new_MDImplicitDelete__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDImplicitDelete";
  FIX::MDImplicitDelete *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDImplicitDelete *)new FIX::MDImplicitDelete();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDImplicitDelete_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDImplicitDelete_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDImplicitDelete);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDImplicitDelete__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDImplicitDelete";
  FIX::MDImplicitDelete *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::MDImplicitDelete", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::MDImplicitDelete", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::MDImplicitDelete *)new FIX::MDImplicitDelete((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDImplicitDelete(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDImplicitDelete__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDImplicitDelete__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDImplicitDelete.new", 
    "    MDImplicitDelete.new()\n"
    "    MDImplicitDelete.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDImplicitDelete(FIX::MDImplicitDelete *arg1) {
    delete arg1;
}

swig_class SwigClassNoStipulations;

SWIGINTERN VALUE
_wrap_new_NoStipulations__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoStipulations";
  FIX::NoStipulations *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoStipulations *)new FIX::NoStipulations();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoStipulations_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoStipulations_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoStipulations);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoStipulations__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStipulations";
  FIX::NoStipulations *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoStipulations", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoStipulations", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoStipulations *)new FIX::NoStipulations((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoStipulations(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoStipulations__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStipulations__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoStipulations.new", 
    "    NoStipulations.new()\n"
    "    NoStipulations.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStipulations(FIX::NoStipulations *arg1) {
    delete arg1;
}

swig_class SwigClassClearingBusinessDate;

SWIGINTERN VALUE
_wrap_new_ClearingBusinessDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClearingBusinessDate";
  FIX::ClearingBusinessDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClearingBusinessDate *)new FIX::ClearingBusinessDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClearingBusinessDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClearingBusinessDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClearingBusinessDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClearingBusinessDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingBusinessDate";
  FIX::ClearingBusinessDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::ClearingBusinessDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::ClearingBusinessDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::ClearingBusinessDate *)new FIX::ClearingBusinessDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClearingBusinessDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClearingBusinessDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingBusinessDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClearingBusinessDate.new", 
    "    ClearingBusinessDate.new()\n"
    "    ClearingBusinessDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingBusinessDate(FIX::ClearingBusinessDate *arg1) {
    delete arg1;
}

swig_class SwigClassLocationID;

SWIGINTERN VALUE
_wrap_new_LocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LocationID";
  FIX::LocationID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LocationID *)new FIX::LocationID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LocationID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LocationID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LocationID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LocationID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocationID";
  FIX::LocationID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LocationID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LocationID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LocationID *)new FIX::LocationID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LocationID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LocationID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocationID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LocationID.new", 
    "    LocationID.new()\n"
    "    LocationID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LocationID(FIX::LocationID *arg1) {
    delete arg1;
}

swig_class SwigClassCurrency;

SWIGINTERN VALUE
_wrap_new_Currency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Currency";
  FIX::Currency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Currency *)new FIX::Currency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Currency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Currency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Currency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Currency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Currency";
  FIX::Currency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::Currency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::Currency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::Currency *)new FIX::Currency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Currency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Currency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Currency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Currency.new", 
    "    Currency.new()\n"
    "    Currency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Currency(FIX::Currency *arg1) {
    delete arg1;
}

swig_class SwigClassRoutingType;

SWIGINTERN VALUE
_wrap_new_RoutingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RoutingType";
  FIX::RoutingType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RoutingType *)new FIX::RoutingType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoutingType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoutingType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RoutingType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoutingType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoutingType";
  FIX::RoutingType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RoutingType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RoutingType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RoutingType *)new FIX::RoutingType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RoutingType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RoutingType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoutingType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RoutingType.new", 
    "    RoutingType.new()\n"
    "    RoutingType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RoutingType(FIX::RoutingType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingStrikePrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikePrice";
  FIX::UnderlyingStrikePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingStrikePrice *)new FIX::UnderlyingStrikePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingStrikePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingStrikePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingStrikePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingStrikePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikePrice";
  FIX::UnderlyingStrikePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingStrikePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingStrikePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingStrikePrice *)new FIX::UnderlyingStrikePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingStrikePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingStrikePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStrikePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingStrikePrice.new", 
    "    UnderlyingStrikePrice.new()\n"
    "    UnderlyingStrikePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStrikePrice(FIX::UnderlyingStrikePrice *arg1) {
    delete arg1;
}

swig_class SwigClassBidTradeType;

SWIGINTERN VALUE
_wrap_new_BidTradeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidTradeType";
  FIX::BidTradeType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidTradeType *)new FIX::BidTradeType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidTradeType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidTradeType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidTradeType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidTradeType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidTradeType";
  FIX::BidTradeType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::BidTradeType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::BidTradeType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::BidTradeType *)new FIX::BidTradeType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidTradeType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidTradeType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidTradeType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidTradeType.new", 
    "    BidTradeType.new()\n"
    "    BidTradeType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidTradeType(FIX::BidTradeType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingAttachmentPoint;

SWIGINTERN VALUE
_wrap_new_UnderlyingAttachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAttachmentPoint";
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingAttachmentPoint *)new FIX::UnderlyingAttachmentPoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingAttachmentPoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingAttachmentPoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingAttachmentPoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingAttachmentPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAttachmentPoint";
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingAttachmentPoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingAttachmentPoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingAttachmentPoint *)new FIX::UnderlyingAttachmentPoint((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingAttachmentPoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingAttachmentPoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingAttachmentPoint__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingAttachmentPoint.new", 
    "    UnderlyingAttachmentPoint.new()\n"
    "    UnderlyingAttachmentPoint.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingAttachmentPoint(FIX::UnderlyingAttachmentPoint *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoRejQuotes;

SWIGINTERN VALUE
_wrap_new_TotNoRejQuotes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoRejQuotes";
  FIX::TotNoRejQuotes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoRejQuotes *)new FIX::TotNoRejQuotes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoRejQuotes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoRejQuotes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoRejQuotes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoRejQuotes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoRejQuotes";
  FIX::TotNoRejQuotes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoRejQuotes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoRejQuotes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoRejQuotes *)new FIX::TotNoRejQuotes((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoRejQuotes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoRejQuotes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoRejQuotes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoRejQuotes.new", 
    "    TotNoRejQuotes.new()\n"
    "    TotNoRejQuotes.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoRejQuotes(FIX::TotNoRejQuotes *arg1) {
    delete arg1;
}

swig_class SwigClassOrdStatusReqID;

SWIGINTERN VALUE
_wrap_new_OrdStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrdStatusReqID";
  FIX::OrdStatusReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrdStatusReqID *)new FIX::OrdStatusReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrdStatusReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrdStatusReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrdStatusReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrdStatusReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdStatusReqID";
  FIX::OrdStatusReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrdStatusReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrdStatusReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrdStatusReqID *)new FIX::OrdStatusReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrdStatusReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrdStatusReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdStatusReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrdStatusReqID.new", 
    "    OrdStatusReqID.new()\n"
    "    OrdStatusReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdStatusReqID(FIX::OrdStatusReqID *arg1) {
    delete arg1;
}

swig_class SwigClassSenderCompID;

SWIGINTERN VALUE
_wrap_new_SenderCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SenderCompID";
  FIX::SenderCompID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SenderCompID *)new FIX::SenderCompID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SenderCompID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SenderCompID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SenderCompID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SenderCompID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderCompID";
  FIX::SenderCompID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SenderCompID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SenderCompID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SenderCompID *)new FIX::SenderCompID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SenderCompID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SenderCompID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderCompID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SenderCompID.new", 
    "    SenderCompID.new()\n"
    "    SenderCompID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SenderCompID(FIX::SenderCompID *arg1) {
    delete arg1;
}

swig_class SwigClassOrdRejReason;

SWIGINTERN VALUE
_wrap_new_OrdRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrdRejReason";
  FIX::OrdRejReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrdRejReason *)new FIX::OrdRejReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrdRejReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrdRejReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrdRejReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrdRejReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdRejReason";
  FIX::OrdRejReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OrdRejReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OrdRejReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OrdRejReason *)new FIX::OrdRejReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrdRejReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrdRejReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdRejReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrdRejReason.new", 
    "    OrdRejReason.new()\n"
    "    OrdRejReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdRejReason(FIX::OrdRejReason *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityMonthYearIncrementUnits;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearIncrementUnits__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrementUnits";
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityMonthYearIncrementUnits *)new FIX::MaturityMonthYearIncrementUnits();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityMonthYearIncrementUnits_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityMonthYearIncrementUnits_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearIncrementUnits__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrementUnits";
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MaturityMonthYearIncrementUnits", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MaturityMonthYearIncrementUnits", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MaturityMonthYearIncrementUnits *)new FIX::MaturityMonthYearIncrementUnits((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityMonthYearIncrementUnits(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityMonthYearIncrementUnits__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYearIncrementUnits__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityMonthYearIncrementUnits.new", 
    "    MaturityMonthYearIncrementUnits.new()\n"
    "    MaturityMonthYearIncrementUnits.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYearIncrementUnits(FIX::MaturityMonthYearIncrementUnits *arg1) {
    delete arg1;
}

swig_class SwigClassDisplayWhen;

SWIGINTERN VALUE
_wrap_new_DisplayWhen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DisplayWhen";
  FIX::DisplayWhen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DisplayWhen *)new FIX::DisplayWhen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DisplayWhen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DisplayWhen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DisplayWhen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DisplayWhen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayWhen";
  FIX::DisplayWhen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DisplayWhen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DisplayWhen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DisplayWhen *)new FIX::DisplayWhen((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DisplayWhen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DisplayWhen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayWhen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DisplayWhen.new", 
    "    DisplayWhen.new()\n"
    "    DisplayWhen.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayWhen(FIX::DisplayWhen *arg1) {
    delete arg1;
}

swig_class SwigClassApplQueueAction;

SWIGINTERN VALUE
_wrap_new_ApplQueueAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueAction";
  FIX::ApplQueueAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplQueueAction *)new FIX::ApplQueueAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplQueueAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplQueueAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplQueueAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplQueueAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueAction";
  FIX::ApplQueueAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplQueueAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplQueueAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplQueueAction *)new FIX::ApplQueueAction((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplQueueAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplQueueAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplQueueAction.new", 
    "    ApplQueueAction.new()\n"
    "    ApplQueueAction.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueAction(FIX::ApplQueueAction *arg1) {
    delete arg1;
}

swig_class SwigClassRegistTransType;

SWIGINTERN VALUE
_wrap_new_RegistTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistTransType";
  FIX::RegistTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistTransType *)new FIX::RegistTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistTransType";
  FIX::RegistTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::RegistTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::RegistTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RegistTransType *)new FIX::RegistTransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistTransType.new", 
    "    RegistTransType.new()\n"
    "    RegistTransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistTransType(FIX::RegistTransType *arg1) {
    delete arg1;
}

swig_class SwigClassPaymentRemitterID;

SWIGINTERN VALUE
_wrap_new_PaymentRemitterID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PaymentRemitterID";
  FIX::PaymentRemitterID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PaymentRemitterID *)new FIX::PaymentRemitterID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PaymentRemitterID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PaymentRemitterID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PaymentRemitterID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PaymentRemitterID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentRemitterID";
  FIX::PaymentRemitterID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PaymentRemitterID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PaymentRemitterID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PaymentRemitterID *)new FIX::PaymentRemitterID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PaymentRemitterID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PaymentRemitterID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentRemitterID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PaymentRemitterID.new", 
    "    PaymentRemitterID.new()\n"
    "    PaymentRemitterID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentRemitterID(FIX::PaymentRemitterID *arg1) {
    delete arg1;
}

swig_class SwigClassPriceType;

SWIGINTERN VALUE
_wrap_new_PriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceType";
  FIX::PriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceType *)new FIX::PriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceType";
  FIX::PriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PriceType *)new FIX::PriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceType.new", 
    "    PriceType.new()\n"
    "    PriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceType(FIX::PriceType *arg1) {
    delete arg1;
}

swig_class SwigClassMarketReqID;

SWIGINTERN VALUE
_wrap_new_MarketReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketReqID";
  FIX::MarketReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketReqID *)new FIX::MarketReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketReqID";
  FIX::MarketReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MarketReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MarketReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MarketReqID *)new FIX::MarketReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketReqID.new", 
    "    MarketReqID.new()\n"
    "    MarketReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketReqID(FIX::MarketReqID *arg1) {
    delete arg1;
}

swig_class SwigClassNoNestedInstrAttrib;

SWIGINTERN VALUE
_wrap_new_NoNestedInstrAttrib__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNestedInstrAttrib";
  FIX::NoNestedInstrAttrib *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNestedInstrAttrib *)new FIX::NoNestedInstrAttrib();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNestedInstrAttrib_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNestedInstrAttrib_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNestedInstrAttrib);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNestedInstrAttrib__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedInstrAttrib";
  FIX::NoNestedInstrAttrib *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNestedInstrAttrib", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNestedInstrAttrib", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNestedInstrAttrib *)new FIX::NoNestedInstrAttrib((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNestedInstrAttrib(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNestedInstrAttrib__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNestedInstrAttrib__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNestedInstrAttrib.new", 
    "    NoNestedInstrAttrib.new()\n"
    "    NoNestedInstrAttrib.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNestedInstrAttrib(FIX::NoNestedInstrAttrib *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySubType;

SWIGINTERN VALUE
_wrap_new_SecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySubType";
  FIX::SecuritySubType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySubType *)new FIX::SecuritySubType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySubType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySubType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySubType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySubType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySubType";
  FIX::SecuritySubType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySubType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySubType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySubType *)new FIX::SecuritySubType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySubType.new", 
    "    SecuritySubType.new()\n"
    "    SecuritySubType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySubType(FIX::SecuritySubType *arg1) {
    delete arg1;
}

swig_class SwigClassClOrdID;

SWIGINTERN VALUE
_wrap_new_ClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClOrdID";
  FIX::ClOrdID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClOrdID *)new FIX::ClOrdID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClOrdID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClOrdID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClOrdID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClOrdID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClOrdID";
  FIX::ClOrdID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClOrdID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClOrdID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClOrdID *)new FIX::ClOrdID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClOrdID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClOrdID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClOrdID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClOrdID.new", 
    "    ClOrdID.new()\n"
    "    ClOrdID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClOrdID(FIX::ClOrdID *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityDay;

SWIGINTERN VALUE
_wrap_new_MaturityDay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityDay";
  FIX::MaturityDay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityDay *)new FIX::MaturityDay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityDay_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityDay_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityDay);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityDay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DAYOFMONTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityDay";
  FIX::MaturityDay *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DAYOFMONTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DAYOFMONTH const &","FIX::MaturityDay", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DAYOFMONTH const &","FIX::MaturityDay", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DAYOFMONTH * >(argp1);
  result = (FIX::MaturityDay *)new FIX::MaturityDay((FIX::DAYOFMONTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityDay(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityDay__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DAYOFMONTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityDay__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityDay.new", 
    "    MaturityDay.new()\n"
    "    MaturityDay.new(FIX::DAYOFMONTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityDay(FIX::MaturityDay *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSeniority;

SWIGINTERN VALUE
_wrap_new_UnderlyingSeniority__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSeniority";
  FIX::UnderlyingSeniority *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSeniority *)new FIX::UnderlyingSeniority();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSeniority_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSeniority_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSeniority);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSeniority__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSeniority";
  FIX::UnderlyingSeniority *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSeniority", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSeniority", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSeniority *)new FIX::UnderlyingSeniority((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSeniority(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSeniority__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSeniority__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSeniority.new", 
    "    UnderlyingSeniority.new()\n"
    "    UnderlyingSeniority.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSeniority(FIX::UnderlyingSeniority *arg1) {
    delete arg1;
}

swig_class SwigClassMarketSegmentDesc;

SWIGINTERN VALUE
_wrap_new_MarketSegmentDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentDesc";
  FIX::MarketSegmentDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketSegmentDesc *)new FIX::MarketSegmentDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketSegmentDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketSegmentDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketSegmentDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketSegmentDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentDesc";
  FIX::MarketSegmentDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MarketSegmentDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MarketSegmentDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MarketSegmentDesc *)new FIX::MarketSegmentDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketSegmentDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketSegmentDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketSegmentDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketSegmentDesc.new", 
    "    MarketSegmentDesc.new()\n"
    "    MarketSegmentDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketSegmentDesc(FIX::MarketSegmentDesc *arg1) {
    delete arg1;
}

swig_class SwigClassNoMarketSegments;

SWIGINTERN VALUE
_wrap_new_NoMarketSegments__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMarketSegments";
  FIX::NoMarketSegments *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMarketSegments *)new FIX::NoMarketSegments();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMarketSegments_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMarketSegments_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMarketSegments);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMarketSegments__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMarketSegments";
  FIX::NoMarketSegments *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMarketSegments", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMarketSegments", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMarketSegments *)new FIX::NoMarketSegments((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMarketSegments(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMarketSegments__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMarketSegments__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMarketSegments.new", 
    "    NoMarketSegments.new()\n"
    "    NoMarketSegments.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMarketSegments(FIX::NoMarketSegments *arg1) {
    delete arg1;
}

swig_class SwigClassSettlObligMode;

SWIGINTERN VALUE
_wrap_new_SettlObligMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMode";
  FIX::SettlObligMode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlObligMode *)new FIX::SettlObligMode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlObligMode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlObligMode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlObligMode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlObligMode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMode";
  FIX::SettlObligMode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlObligMode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlObligMode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlObligMode *)new FIX::SettlObligMode((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlObligMode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlObligMode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligMode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlObligMode.new", 
    "    SettlObligMode.new()\n"
    "    SettlObligMode.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligMode(FIX::SettlObligMode *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityUpdateAction;

SWIGINTERN VALUE
_wrap_new_SecurityUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityUpdateAction";
  FIX::SecurityUpdateAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityUpdateAction *)new FIX::SecurityUpdateAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityUpdateAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityUpdateAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityUpdateAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityUpdateAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityUpdateAction";
  FIX::SecurityUpdateAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SecurityUpdateAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SecurityUpdateAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SecurityUpdateAction *)new FIX::SecurityUpdateAction((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityUpdateAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityUpdateAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityUpdateAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityUpdateAction.new", 
    "    SecurityUpdateAction.new()\n"
    "    SecurityUpdateAction.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityUpdateAction(FIX::SecurityUpdateAction *arg1) {
    delete arg1;
}

swig_class SwigClassNetworkRequestType;

SWIGINTERN VALUE
_wrap_new_NetworkRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestType";
  FIX::NetworkRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetworkRequestType *)new FIX::NetworkRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetworkRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetworkRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetworkRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetworkRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestType";
  FIX::NetworkRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NetworkRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NetworkRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NetworkRequestType *)new FIX::NetworkRequestType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetworkRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetworkRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetworkRequestType.new", 
    "    NetworkRequestType.new()\n"
    "    NetworkRequestType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkRequestType(FIX::NetworkRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassLiquidityPctLow;

SWIGINTERN VALUE
_wrap_new_LiquidityPctLow__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctLow";
  FIX::LiquidityPctLow *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LiquidityPctLow *)new FIX::LiquidityPctLow();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LiquidityPctLow_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LiquidityPctLow_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LiquidityPctLow);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LiquidityPctLow__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctLow";
  FIX::LiquidityPctLow *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::LiquidityPctLow", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::LiquidityPctLow", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::LiquidityPctLow *)new FIX::LiquidityPctLow((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LiquidityPctLow(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LiquidityPctLow__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityPctLow__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LiquidityPctLow.new", 
    "    LiquidityPctLow.new()\n"
    "    LiquidityPctLow.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityPctLow(FIX::LiquidityPctLow *arg1) {
    delete arg1;
}

swig_class SwigClassPartyRole;

SWIGINTERN VALUE
_wrap_new_PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PartyRole";
  FIX::PartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PartyRole *)new FIX::PartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyRole";
  FIX::PartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PartyRole *)new FIX::PartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PartyRole.new", 
    "    PartyRole.new()\n"
    "    PartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyRole(FIX::PartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassLegRatioQty;

SWIGINTERN VALUE
_wrap_new_LegRatioQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegRatioQty";
  FIX::LegRatioQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegRatioQty *)new FIX::LegRatioQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegRatioQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegRatioQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegRatioQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegRatioQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRatioQty";
  FIX::LegRatioQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::LegRatioQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::LegRatioQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::LegRatioQty *)new FIX::LegRatioQty((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegRatioQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegRatioQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRatioQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegRatioQty.new", 
    "    LegRatioQty.new()\n"
    "    LegRatioQty.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRatioQty(FIX::LegRatioQty *arg1) {
    delete arg1;
}

swig_class SwigClassSettlCurrFxRate;

SWIGINTERN VALUE
_wrap_new_SettlCurrFxRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRate";
  FIX::SettlCurrFxRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlCurrFxRate *)new FIX::SettlCurrFxRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlCurrFxRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlCurrFxRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlCurrFxRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlCurrFxRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRate";
  FIX::SettlCurrFxRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::SettlCurrFxRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::SettlCurrFxRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::SettlCurrFxRate *)new FIX::SettlCurrFxRate((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlCurrFxRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlCurrFxRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrFxRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlCurrFxRate.new", 
    "    SettlCurrFxRate.new()\n"
    "    SettlCurrFxRate.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrFxRate(FIX::SettlCurrFxRate *arg1) {
    delete arg1;
}

swig_class SwigClassLegContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_LegContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplierUnit";
  FIX::LegContractMultiplierUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegContractMultiplierUnit *)new FIX::LegContractMultiplierUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegContractMultiplierUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegContractMultiplierUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegContractMultiplierUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegContractMultiplierUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplierUnit";
  FIX::LegContractMultiplierUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegContractMultiplierUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegContractMultiplierUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegContractMultiplierUnit *)new FIX::LegContractMultiplierUnit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegContractMultiplierUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegContractMultiplierUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegContractMultiplierUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegContractMultiplierUnit.new", 
    "    LegContractMultiplierUnit.new()\n"
    "    LegContractMultiplierUnit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegContractMultiplierUnit(FIX::LegContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class SwigClassSecureData;

SWIGINTERN VALUE
_wrap_new_SecureData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecureData";
  FIX::SecureData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecureData *)new FIX::SecureData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecureData_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecureData_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecureData);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecureData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecureData";
  FIX::SecureData *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::SecureData", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::SecureData", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::SecureData *)new FIX::SecureData((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecureData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecureData__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecureData__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecureData.new", 
    "    SecureData.new()\n"
    "    SecureData.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecureData(FIX::SecureData *arg1) {
    delete arg1;
}

swig_class SwigClassSenderLocationID;

SWIGINTERN VALUE
_wrap_new_SenderLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SenderLocationID";
  FIX::SenderLocationID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SenderLocationID *)new FIX::SenderLocationID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SenderLocationID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SenderLocationID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SenderLocationID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SenderLocationID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderLocationID";
  FIX::SenderLocationID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SenderLocationID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SenderLocationID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SenderLocationID *)new FIX::SenderLocationID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SenderLocationID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SenderLocationID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderLocationID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SenderLocationID.new", 
    "    SenderLocationID.new()\n"
    "    SenderLocationID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SenderLocationID(FIX::SenderLocationID *arg1) {
    delete arg1;
}

swig_class SwigClassFirstPx;

SWIGINTERN VALUE
_wrap_new_FirstPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FirstPx";
  FIX::FirstPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FirstPx *)new FIX::FirstPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FirstPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FirstPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FirstPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FirstPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FirstPx";
  FIX::FirstPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::FirstPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::FirstPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::FirstPx *)new FIX::FirstPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FirstPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FirstPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FirstPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FirstPx.new", 
    "    FirstPx.new()\n"
    "    FirstPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FirstPx(FIX::FirstPx *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedLegIssuer;

SWIGINTERN VALUE
_wrap_new_EncodedLegIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuer";
  FIX::EncodedLegIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedLegIssuer *)new FIX::EncodedLegIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedLegIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedLegIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedLegIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedLegIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuer";
  FIX::EncodedLegIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedLegIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedLegIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedLegIssuer *)new FIX::EncodedLegIssuer((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedLegIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedLegIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedLegIssuer.new", 
    "    EncodedLegIssuer.new()\n"
    "    EncodedLegIssuer.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegIssuer(FIX::EncodedLegIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassAssignmentMethod;

SWIGINTERN VALUE
_wrap_new_AssignmentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AssignmentMethod";
  FIX::AssignmentMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AssignmentMethod *)new FIX::AssignmentMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AssignmentMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AssignmentMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AssignmentMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AssignmentMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AssignmentMethod";
  FIX::AssignmentMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::AssignmentMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::AssignmentMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::AssignmentMethod *)new FIX::AssignmentMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AssignmentMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AssignmentMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AssignmentMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AssignmentMethod.new", 
    "    AssignmentMethod.new()\n"
    "    AssignmentMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AssignmentMethod(FIX::AssignmentMethod *arg1) {
    delete arg1;
}

swig_class SwigClassRoutingID;

SWIGINTERN VALUE
_wrap_new_RoutingID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RoutingID";
  FIX::RoutingID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RoutingID *)new FIX::RoutingID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoutingID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoutingID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RoutingID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoutingID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoutingID";
  FIX::RoutingID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RoutingID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RoutingID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RoutingID *)new FIX::RoutingID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RoutingID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RoutingID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoutingID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RoutingID.new", 
    "    RoutingID.new()\n"
    "    RoutingID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RoutingID(FIX::RoutingID *arg1) {
    delete arg1;
}

swig_class SwigClassStrategyParameterType;

SWIGINTERN VALUE
_wrap_new_StrategyParameterType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterType";
  FIX::StrategyParameterType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrategyParameterType *)new FIX::StrategyParameterType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrategyParameterType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrategyParameterType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrategyParameterType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrategyParameterType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterType";
  FIX::StrategyParameterType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StrategyParameterType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StrategyParameterType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StrategyParameterType *)new FIX::StrategyParameterType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrategyParameterType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrategyParameterType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrategyParameterType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrategyParameterType.new", 
    "    StrategyParameterType.new()\n"
    "    StrategyParameterType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrategyParameterType(FIX::StrategyParameterType *arg1) {
    delete arg1;
}

swig_class SwigClassEncryptMethod;

SWIGINTERN VALUE
_wrap_new_EncryptMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncryptMethod";
  FIX::EncryptMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncryptMethod *)new FIX::EncryptMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncryptMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncryptMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncryptMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncryptMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptMethod";
  FIX::EncryptMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::EncryptMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::EncryptMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::EncryptMethod *)new FIX::EncryptMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncryptMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncryptMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncryptMethod.new", 
    "    EncryptMethod.new()\n"
    "    EncryptMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptMethod(FIX::EncryptMethod *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStateOrProvinceOfIssue";
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingStateOrProvinceOfIssue *)new FIX::UnderlyingStateOrProvinceOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingStateOrProvinceOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingStateOrProvinceOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStateOrProvinceOfIssue";
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingStateOrProvinceOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingStateOrProvinceOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingStateOrProvinceOfIssue *)new FIX::UnderlyingStateOrProvinceOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingStateOrProvinceOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingStateOrProvinceOfIssue.new", 
    "    UnderlyingStateOrProvinceOfIssue.new()\n"
    "    UnderlyingStateOrProvinceOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStateOrProvinceOfIssue(FIX::UnderlyingStateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassApplNewSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplNewSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplNewSeqNum";
  FIX::ApplNewSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplNewSeqNum *)new FIX::ApplNewSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplNewSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplNewSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplNewSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplNewSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplNewSeqNum";
  FIX::ApplNewSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::ApplNewSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::ApplNewSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::ApplNewSeqNum *)new FIX::ApplNewSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplNewSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplNewSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplNewSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplNewSeqNum.new", 
    "    ApplNewSeqNum.new()\n"
    "    ApplNewSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplNewSeqNum(FIX::ApplNewSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEncodedSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDescLen";
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEncodedSecurityDescLen *)new FIX::DerivativeEncodedSecurityDescLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEncodedSecurityDescLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEncodedSecurityDescLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedSecurityDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDescLen";
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::DerivativeEncodedSecurityDescLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::DerivativeEncodedSecurityDescLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::DerivativeEncodedSecurityDescLen *)new FIX::DerivativeEncodedSecurityDescLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEncodedSecurityDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEncodedSecurityDescLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedSecurityDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEncodedSecurityDescLen.new", 
    "    DerivativeEncodedSecurityDescLen.new()\n"
    "    DerivativeEncodedSecurityDescLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedSecurityDescLen(FIX::DerivativeEncodedSecurityDescLen *arg1) {
    delete arg1;
}

swig_class SwigClassTradingCurrency;

SWIGINTERN VALUE
_wrap_new_TradingCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradingCurrency";
  FIX::TradingCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradingCurrency *)new FIX::TradingCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradingCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradingCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradingCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradingCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingCurrency";
  FIX::TradingCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::TradingCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::TradingCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::TradingCurrency *)new FIX::TradingCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradingCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradingCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradingCurrency.new", 
    "    TradingCurrency.new()\n"
    "    TradingCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingCurrency(FIX::TradingCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryHighLimitPrice;

SWIGINTERN VALUE
_wrap_new_SecondaryHighLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryHighLimitPrice";
  FIX::SecondaryHighLimitPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryHighLimitPrice *)new FIX::SecondaryHighLimitPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryHighLimitPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryHighLimitPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryHighLimitPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryHighLimitPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryHighLimitPrice";
  FIX::SecondaryHighLimitPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::SecondaryHighLimitPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::SecondaryHighLimitPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::SecondaryHighLimitPrice *)new FIX::SecondaryHighLimitPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryHighLimitPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryHighLimitPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryHighLimitPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryHighLimitPrice.new", 
    "    SecondaryHighLimitPrice.new()\n"
    "    SecondaryHighLimitPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryHighLimitPrice(FIX::SecondaryHighLimitPrice *arg1) {
    delete arg1;
}

swig_class SwigClassOrderAvgPx;

SWIGINTERN VALUE
_wrap_new_OrderAvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderAvgPx";
  FIX::OrderAvgPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderAvgPx *)new FIX::OrderAvgPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderAvgPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderAvgPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderAvgPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderAvgPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderAvgPx";
  FIX::OrderAvgPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::OrderAvgPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::OrderAvgPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::OrderAvgPx *)new FIX::OrderAvgPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderAvgPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderAvgPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderAvgPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderAvgPx.new", 
    "    OrderAvgPx.new()\n"
    "    OrderAvgPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderAvgPx(FIX::OrderAvgPx *arg1) {
    delete arg1;
}

swig_class SwigClassPosAmtType;

SWIGINTERN VALUE
_wrap_new_PosAmtType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosAmtType";
  FIX::PosAmtType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosAmtType *)new FIX::PosAmtType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosAmtType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosAmtType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosAmtType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosAmtType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosAmtType";
  FIX::PosAmtType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PosAmtType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PosAmtType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PosAmtType *)new FIX::PosAmtType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosAmtType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosAmtType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosAmtType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosAmtType.new", 
    "    PosAmtType.new()\n"
    "    PosAmtType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosAmtType(FIX::PosAmtType *arg1) {
    delete arg1;
}

swig_class SwigClassResetSeqNumFlag;

SWIGINTERN VALUE
_wrap_new_ResetSeqNumFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ResetSeqNumFlag";
  FIX::ResetSeqNumFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ResetSeqNumFlag *)new FIX::ResetSeqNumFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ResetSeqNumFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ResetSeqNumFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ResetSeqNumFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ResetSeqNumFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResetSeqNumFlag";
  FIX::ResetSeqNumFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ResetSeqNumFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ResetSeqNumFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ResetSeqNumFlag *)new FIX::ResetSeqNumFlag((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ResetSeqNumFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ResetSeqNumFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResetSeqNumFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ResetSeqNumFlag.new", 
    "    ResetSeqNumFlag.new()\n"
    "    ResetSeqNumFlag.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ResetSeqNumFlag(FIX::ResetSeqNumFlag *arg1) {
    delete arg1;
}

swig_class SwigClassNoHops;

SWIGINTERN VALUE
_wrap_new_NoHops__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoHops";
  FIX::NoHops *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoHops *)new FIX::NoHops();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoHops_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoHops_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoHops);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoHops__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoHops";
  FIX::NoHops *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoHops", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoHops", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoHops *)new FIX::NoHops((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoHops(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoHops__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoHops__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoHops.new", 
    "    NoHops.new()\n"
    "    NoHops.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoHops(FIX::NoHops *arg1) {
    delete arg1;
}

swig_class SwigClassCollInquiryResult;

SWIGINTERN VALUE
_wrap_new_CollInquiryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryResult";
  FIX::CollInquiryResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollInquiryResult *)new FIX::CollInquiryResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollInquiryResult_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollInquiryResult_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollInquiryResult);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollInquiryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryResult";
  FIX::CollInquiryResult *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollInquiryResult", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollInquiryResult", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollInquiryResult *)new FIX::CollInquiryResult((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollInquiryResult(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollInquiryResult__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryResult__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollInquiryResult.new", 
    "    CollInquiryResult.new()\n"
    "    CollInquiryResult.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryResult(FIX::CollInquiryResult *arg1) {
    delete arg1;
}

swig_class SwigClassStartDate;

SWIGINTERN VALUE
_wrap_new_StartDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StartDate";
  FIX::StartDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StartDate *)new FIX::StartDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StartDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StartDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StartDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StartDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartDate";
  FIX::StartDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::StartDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::StartDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::StartDate *)new FIX::StartDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StartDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StartDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StartDate.new", 
    "    StartDate.new()\n"
    "    StartDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StartDate(FIX::StartDate *arg1) {
    delete arg1;
}

swig_class SwigClassCollAsgnRespType;

SWIGINTERN VALUE
_wrap_new_CollAsgnRespType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRespType";
  FIX::CollAsgnRespType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAsgnRespType *)new FIX::CollAsgnRespType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAsgnRespType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAsgnRespType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAsgnRespType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAsgnRespType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRespType";
  FIX::CollAsgnRespType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollAsgnRespType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollAsgnRespType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollAsgnRespType *)new FIX::CollAsgnRespType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAsgnRespType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAsgnRespType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnRespType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAsgnRespType.new", 
    "    CollAsgnRespType.new()\n"
    "    CollAsgnRespType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnRespType(FIX::CollAsgnRespType *arg1) {
    delete arg1;
}

swig_class SwigClassOrderBookingQty;

SWIGINTERN VALUE
_wrap_new_OrderBookingQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderBookingQty";
  FIX::OrderBookingQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderBookingQty *)new FIX::OrderBookingQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderBookingQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderBookingQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderBookingQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderBookingQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderBookingQty";
  FIX::OrderBookingQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::OrderBookingQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::OrderBookingQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::OrderBookingQty *)new FIX::OrderBookingQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderBookingQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderBookingQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderBookingQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderBookingQty.new", 
    "    OrderBookingQty.new()\n"
    "    OrderBookingQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderBookingQty(FIX::OrderBookingQty *arg1) {
    delete arg1;
}

swig_class SwigClassNoQuoteQualifiers;

SWIGINTERN VALUE
_wrap_new_NoQuoteQualifiers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteQualifiers";
  FIX::NoQuoteQualifiers *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoQuoteQualifiers *)new FIX::NoQuoteQualifiers();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoQuoteQualifiers_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoQuoteQualifiers_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoQuoteQualifiers);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoQuoteQualifiers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteQualifiers";
  FIX::NoQuoteQualifiers *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoQuoteQualifiers", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoQuoteQualifiers", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoQuoteQualifiers *)new FIX::NoQuoteQualifiers((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoQuoteQualifiers(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoQuoteQualifiers__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoQuoteQualifiers__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoQuoteQualifiers.new", 
    "    NoQuoteQualifiers.new()\n"
    "    NoQuoteQualifiers.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoQuoteQualifiers(FIX::NoQuoteQualifiers *arg1) {
    delete arg1;
}

swig_class SwigClassUnsolicitedIndicator;

SWIGINTERN VALUE
_wrap_new_UnsolicitedIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnsolicitedIndicator";
  FIX::UnsolicitedIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnsolicitedIndicator *)new FIX::UnsolicitedIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnsolicitedIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnsolicitedIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnsolicitedIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnsolicitedIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnsolicitedIndicator";
  FIX::UnsolicitedIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::UnsolicitedIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::UnsolicitedIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::UnsolicitedIndicator *)new FIX::UnsolicitedIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnsolicitedIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnsolicitedIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsolicitedIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnsolicitedIndicator.new", 
    "    UnsolicitedIndicator.new()\n"
    "    UnsolicitedIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnsolicitedIndicator(FIX::UnsolicitedIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassRefCstmApplVerID;

SWIGINTERN VALUE
_wrap_new_RefCstmApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefCstmApplVerID";
  FIX::RefCstmApplVerID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefCstmApplVerID *)new FIX::RefCstmApplVerID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefCstmApplVerID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefCstmApplVerID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefCstmApplVerID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefCstmApplVerID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefCstmApplVerID";
  FIX::RefCstmApplVerID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefCstmApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefCstmApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefCstmApplVerID *)new FIX::RefCstmApplVerID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefCstmApplVerID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefCstmApplVerID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefCstmApplVerID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefCstmApplVerID.new", 
    "    RefCstmApplVerID.new()\n"
    "    RefCstmApplVerID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefCstmApplVerID(FIX::RefCstmApplVerID *arg1) {
    delete arg1;
}

swig_class SwigClassSideExecID;

SWIGINTERN VALUE
_wrap_new_SideExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideExecID";
  FIX::SideExecID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideExecID *)new FIX::SideExecID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideExecID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideExecID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideExecID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideExecID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideExecID";
  FIX::SideExecID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SideExecID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SideExecID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SideExecID *)new FIX::SideExecID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideExecID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideExecID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideExecID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideExecID.new", 
    "    SideExecID.new()\n"
    "    SideExecID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideExecID(FIX::SideExecID *arg1) {
    delete arg1;
}

swig_class SwigClassRejectText;

SWIGINTERN VALUE
_wrap_new_RejectText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RejectText";
  FIX::RejectText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RejectText *)new FIX::RejectText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RejectText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RejectText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RejectText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RejectText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RejectText";
  FIX::RejectText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RejectText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RejectText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RejectText *)new FIX::RejectText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RejectText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RejectText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RejectText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RejectText.new", 
    "    RejectText.new()\n"
    "    RejectText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RejectText(FIX::RejectText *arg1) {
    delete arg1;
}

swig_class SwigClassExchangeSpecialInstructions;

SWIGINTERN VALUE
_wrap_new_ExchangeSpecialInstructions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExchangeSpecialInstructions";
  FIX::ExchangeSpecialInstructions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExchangeSpecialInstructions *)new FIX::ExchangeSpecialInstructions();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExchangeSpecialInstructions_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExchangeSpecialInstructions_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExchangeSpecialInstructions);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExchangeSpecialInstructions__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeSpecialInstructions";
  FIX::ExchangeSpecialInstructions *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ExchangeSpecialInstructions", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ExchangeSpecialInstructions", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ExchangeSpecialInstructions *)new FIX::ExchangeSpecialInstructions((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExchangeSpecialInstructions(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExchangeSpecialInstructions__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExchangeSpecialInstructions__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExchangeSpecialInstructions.new", 
    "    ExchangeSpecialInstructions.new()\n"
    "    ExchangeSpecialInstructions.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExchangeSpecialInstructions(FIX::ExchangeSpecialInstructions *arg1) {
    delete arg1;
}

swig_class SwigClassTradeID;

SWIGINTERN VALUE
_wrap_new_TradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeID";
  FIX::TradeID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeID *)new FIX::TradeID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeID";
  FIX::TradeID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeID *)new FIX::TradeID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeID.new", 
    "    TradeID.new()\n"
    "    TradeID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeID(FIX::TradeID *arg1) {
    delete arg1;
}

swig_class SwigClassRndPx;

SWIGINTERN VALUE
_wrap_new_RndPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RndPx";
  FIX::RndPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RndPx *)new FIX::RndPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RndPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RndPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RndPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RndPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RndPx";
  FIX::RndPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::RndPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::RndPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::RndPx *)new FIX::RndPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RndPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RndPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RndPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RndPx.new", 
    "    RndPx.new()\n"
    "    RndPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RndPx(FIX::RndPx *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteEntryRejectReason;

SWIGINTERN VALUE
_wrap_new_QuoteEntryRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryRejectReason";
  FIX::QuoteEntryRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteEntryRejectReason *)new FIX::QuoteEntryRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteEntryRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteEntryRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteEntryRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryRejectReason";
  FIX::QuoteEntryRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteEntryRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteEntryRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteEntryRejectReason *)new FIX::QuoteEntryRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteEntryRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteEntryRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteEntryRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteEntryRejectReason.new", 
    "    QuoteEntryRejectReason.new()\n"
    "    QuoteEntryRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteEntryRejectReason(FIX::QuoteEntryRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassOrderCapacity;

SWIGINTERN VALUE
_wrap_new_OrderCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacity";
  FIX::OrderCapacity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderCapacity *)new FIX::OrderCapacity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderCapacity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderCapacity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderCapacity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderCapacity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacity";
  FIX::OrderCapacity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OrderCapacity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OrderCapacity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OrderCapacity *)new FIX::OrderCapacity((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderCapacity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderCapacity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderCapacity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderCapacity.new", 
    "    OrderCapacity.new()\n"
    "    OrderCapacity.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderCapacity(FIX::OrderCapacity *arg1) {
    delete arg1;
}

swig_class SwigClassSideLastQty;

SWIGINTERN VALUE
_wrap_new_SideLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideLastQty";
  FIX::SideLastQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideLastQty *)new FIX::SideLastQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideLastQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideLastQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideLastQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideLastQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideLastQty";
  FIX::SideLastQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideLastQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideLastQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideLastQty *)new FIX::SideLastQty((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideLastQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideLastQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideLastQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideLastQty.new", 
    "    SideLastQty.new()\n"
    "    SideLastQty.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideLastQty(FIX::SideLastQty *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_DerivativeUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasure";
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeUnitOfMeasure *)new FIX::DerivativeUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasure";
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeUnitOfMeasure *)new FIX::DerivativeUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeUnitOfMeasure.new", 
    "    DerivativeUnitOfMeasure.new()\n"
    "    DerivativeUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeUnitOfMeasure(FIX::DerivativeUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassNoLegAllocs;

SWIGINTERN VALUE
_wrap_new_NoLegAllocs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoLegAllocs";
  FIX::NoLegAllocs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoLegAllocs *)new FIX::NoLegAllocs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoLegAllocs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoLegAllocs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoLegAllocs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoLegAllocs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegAllocs";
  FIX::NoLegAllocs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoLegAllocs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoLegAllocs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoLegAllocs *)new FIX::NoLegAllocs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoLegAllocs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoLegAllocs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegAllocs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoLegAllocs.new", 
    "    NoLegAllocs.new()\n"
    "    NoLegAllocs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegAllocs(FIX::NoLegAllocs *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteAckStatus;

SWIGINTERN VALUE
_wrap_new_QuoteAckStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteAckStatus";
  FIX::QuoteAckStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteAckStatus *)new FIX::QuoteAckStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteAckStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteAckStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteAckStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteAckStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteAckStatus";
  FIX::QuoteAckStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteAckStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteAckStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteAckStatus *)new FIX::QuoteAckStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteAckStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteAckStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteAckStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteAckStatus.new", 
    "    QuoteAckStatus.new()\n"
    "    QuoteAckStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteAckStatus(FIX::QuoteAckStatus *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryFirmTradeID;

SWIGINTERN VALUE
_wrap_new_SecondaryFirmTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryFirmTradeID";
  FIX::SecondaryFirmTradeID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryFirmTradeID *)new FIX::SecondaryFirmTradeID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryFirmTradeID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryFirmTradeID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryFirmTradeID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryFirmTradeID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryFirmTradeID";
  FIX::SecondaryFirmTradeID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryFirmTradeID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryFirmTradeID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryFirmTradeID *)new FIX::SecondaryFirmTradeID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryFirmTradeID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryFirmTradeID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryFirmTradeID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryFirmTradeID.new", 
    "    SecondaryFirmTradeID.new()\n"
    "    SecondaryFirmTradeID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryFirmTradeID(FIX::SecondaryFirmTradeID *arg1) {
    delete arg1;
}

swig_class SwigClassUserRequestType;

SWIGINTERN VALUE
_wrap_new_UserRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UserRequestType";
  FIX::UserRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UserRequestType *)new FIX::UserRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UserRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UserRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UserRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UserRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserRequestType";
  FIX::UserRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UserRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UserRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UserRequestType *)new FIX::UserRequestType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UserRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UserRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UserRequestType.new", 
    "    UserRequestType.new()\n"
    "    UserRequestType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UserRequestType(FIX::UserRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryTrdType;

SWIGINTERN VALUE
_wrap_new_SecondaryTrdType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTrdType";
  FIX::SecondaryTrdType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryTrdType *)new FIX::SecondaryTrdType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryTrdType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryTrdType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryTrdType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryTrdType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTrdType";
  FIX::SecondaryTrdType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecondaryTrdType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecondaryTrdType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecondaryTrdType *)new FIX::SecondaryTrdType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryTrdType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryTrdType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTrdType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryTrdType.new", 
    "    SecondaryTrdType.new()\n"
    "    SecondaryTrdType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTrdType(FIX::SecondaryTrdType *arg1) {
    delete arg1;
}

swig_class SwigClassTradeReportTransType;

SWIGINTERN VALUE
_wrap_new_TradeReportTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeReportTransType";
  FIX::TradeReportTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeReportTransType *)new FIX::TradeReportTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeReportTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeReportTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeReportTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeReportTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportTransType";
  FIX::TradeReportTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeReportTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeReportTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeReportTransType *)new FIX::TradeReportTransType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeReportTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeReportTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeReportTransType.new", 
    "    TradeReportTransType.new()\n"
    "    TradeReportTransType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportTransType(FIX::TradeReportTransType *arg1) {
    delete arg1;
}

swig_class SwigClassAdvSide;

SWIGINTERN VALUE
_wrap_new_AdvSide__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AdvSide";
  FIX::AdvSide *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AdvSide *)new FIX::AdvSide();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AdvSide_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AdvSide_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AdvSide);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AdvSide__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvSide";
  FIX::AdvSide *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::AdvSide", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::AdvSide", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::AdvSide *)new FIX::AdvSide((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AdvSide(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AdvSide__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvSide__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AdvSide.new", 
    "    AdvSide.new()\n"
    "    AdvSide.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvSide(FIX::AdvSide *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecuritySubType;

SWIGINTERN VALUE
_wrap_new_DerivativeSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecuritySubType";
  FIX::DerivativeSecuritySubType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecuritySubType *)new FIX::DerivativeSecuritySubType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecuritySubType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecuritySubType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecuritySubType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecuritySubType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecuritySubType";
  FIX::DerivativeSecuritySubType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecuritySubType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecuritySubType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecuritySubType *)new FIX::DerivativeSecuritySubType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecuritySubType.new", 
    "    DerivativeSecuritySubType.new()\n"
    "    DerivativeSecuritySubType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecuritySubType(FIX::DerivativeSecuritySubType *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerTradingSessionSubID;

SWIGINTERN VALUE
_wrap_new_TriggerTradingSessionSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionSubID";
  FIX::TriggerTradingSessionSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerTradingSessionSubID *)new FIX::TriggerTradingSessionSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerTradingSessionSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerTradingSessionSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerTradingSessionSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerTradingSessionSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionSubID";
  FIX::TriggerTradingSessionSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TriggerTradingSessionSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TriggerTradingSessionSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TriggerTradingSessionSubID *)new FIX::TriggerTradingSessionSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerTradingSessionSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerTradingSessionSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerTradingSessionSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerTradingSessionSubID.new", 
    "    TriggerTradingSessionSubID.new()\n"
    "    TriggerTradingSessionSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerTradingSessionSubID(FIX::TriggerTradingSessionSubID *arg1) {
    delete arg1;
}

swig_class SwigClassTradeLinkID;

SWIGINTERN VALUE
_wrap_new_TradeLinkID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeLinkID";
  FIX::TradeLinkID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeLinkID *)new FIX::TradeLinkID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeLinkID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeLinkID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeLinkID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeLinkID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeLinkID";
  FIX::TradeLinkID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeLinkID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeLinkID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeLinkID *)new FIX::TradeLinkID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeLinkID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeLinkID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeLinkID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeLinkID.new", 
    "    TradeLinkID.new()\n"
    "    TradeLinkID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeLinkID(FIX::TradeLinkID *arg1) {
    delete arg1;
}

swig_class SwigClassLegBenchmarkPrice;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPrice";
  FIX::LegBenchmarkPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBenchmarkPrice *)new FIX::LegBenchmarkPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBenchmarkPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBenchmarkPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBenchmarkPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBenchmarkPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPrice";
  FIX::LegBenchmarkPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LegBenchmarkPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LegBenchmarkPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LegBenchmarkPrice *)new FIX::LegBenchmarkPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBenchmarkPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBenchmarkPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBenchmarkPrice.new", 
    "    LegBenchmarkPrice.new()\n"
    "    LegBenchmarkPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkPrice(FIX::LegBenchmarkPrice *arg1) {
    delete arg1;
}

swig_class SwigClassHopRefID;

SWIGINTERN VALUE
_wrap_new_HopRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HopRefID";
  FIX::HopRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HopRefID *)new FIX::HopRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HopRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HopRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HopRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HopRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopRefID";
  FIX::HopRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::HopRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::HopRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::HopRefID *)new FIX::HopRefID((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HopRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HopRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HopRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HopRefID.new", 
    "    HopRefID.new()\n"
    "    HopRefID.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HopRefID(FIX::HopRefID *arg1) {
    delete arg1;
}

swig_class SwigClassDesignation;

SWIGINTERN VALUE
_wrap_new_Designation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Designation";
  FIX::Designation *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Designation *)new FIX::Designation();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Designation_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Designation_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Designation);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Designation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Designation";
  FIX::Designation *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Designation", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Designation", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Designation *)new FIX::Designation((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Designation(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Designation__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Designation__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Designation.new", 
    "    Designation.new()\n"
    "    Designation.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Designation(FIX::Designation *arg1) {
    delete arg1;
}

swig_class SwigClassTradeRequestID;

SWIGINTERN VALUE
_wrap_new_TradeRequestID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestID";
  FIX::TradeRequestID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeRequestID *)new FIX::TradeRequestID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeRequestID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeRequestID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeRequestID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeRequestID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestID";
  FIX::TradeRequestID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeRequestID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeRequestID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeRequestID *)new FIX::TradeRequestID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeRequestID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeRequestID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeRequestID.new", 
    "    TradeRequestID.new()\n"
    "    TradeRequestID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestID(FIX::TradeRequestID *arg1) {
    delete arg1;
}

swig_class SwigClassLegFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_LegFlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegFlowScheduleType";
  FIX::LegFlowScheduleType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegFlowScheduleType *)new FIX::LegFlowScheduleType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegFlowScheduleType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegFlowScheduleType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegFlowScheduleType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegFlowScheduleType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFlowScheduleType";
  FIX::LegFlowScheduleType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegFlowScheduleType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegFlowScheduleType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegFlowScheduleType *)new FIX::LegFlowScheduleType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegFlowScheduleType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegFlowScheduleType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegFlowScheduleType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegFlowScheduleType.new", 
    "    LegFlowScheduleType.new()\n"
    "    LegFlowScheduleType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegFlowScheduleType(FIX::LegFlowScheduleType *arg1) {
    delete arg1;
}

swig_class SwigClassLegPriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_LegPriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasure";
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPriceUnitOfMeasure *)new FIX::LegPriceUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPriceUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPriceUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPriceUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPriceUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasure";
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegPriceUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegPriceUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegPriceUnitOfMeasure *)new FIX::LegPriceUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPriceUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPriceUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPriceUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPriceUnitOfMeasure.new", 
    "    LegPriceUnitOfMeasure.new()\n"
    "    LegPriceUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPriceUnitOfMeasure(FIX::LegPriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassNested4PartyIDSource;

SWIGINTERN VALUE
_wrap_new_Nested4PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyIDSource";
  FIX::Nested4PartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested4PartyIDSource *)new FIX::Nested4PartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested4PartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested4PartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested4PartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested4PartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyIDSource";
  FIX::Nested4PartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Nested4PartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Nested4PartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Nested4PartyIDSource *)new FIX::Nested4PartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested4PartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested4PartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested4PartyIDSource.new", 
    "    Nested4PartyIDSource.new()\n"
    "    Nested4PartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartyIDSource(FIX::Nested4PartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassCoveredOrUncovered;

SWIGINTERN VALUE
_wrap_new_CoveredOrUncovered__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CoveredOrUncovered";
  FIX::CoveredOrUncovered *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CoveredOrUncovered *)new FIX::CoveredOrUncovered();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CoveredOrUncovered_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CoveredOrUncovered_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CoveredOrUncovered);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CoveredOrUncovered__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CoveredOrUncovered";
  FIX::CoveredOrUncovered *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CoveredOrUncovered", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CoveredOrUncovered", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CoveredOrUncovered *)new FIX::CoveredOrUncovered((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CoveredOrUncovered(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CoveredOrUncovered__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CoveredOrUncovered__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CoveredOrUncovered.new", 
    "    CoveredOrUncovered.new()\n"
    "    CoveredOrUncovered.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CoveredOrUncovered(FIX::CoveredOrUncovered *arg1) {
    delete arg1;
}

swig_class SwigClassAcctIDSource;

SWIGINTERN VALUE
_wrap_new_AcctIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AcctIDSource";
  FIX::AcctIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AcctIDSource *)new FIX::AcctIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AcctIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AcctIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AcctIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AcctIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AcctIDSource";
  FIX::AcctIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AcctIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AcctIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AcctIDSource *)new FIX::AcctIDSource((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AcctIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AcctIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AcctIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AcctIDSource.new", 
    "    AcctIDSource.new()\n"
    "    AcctIDSource.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AcctIDSource(FIX::AcctIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassMktOfferPx;

SWIGINTERN VALUE
_wrap_new_MktOfferPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MktOfferPx";
  FIX::MktOfferPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MktOfferPx *)new FIX::MktOfferPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MktOfferPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MktOfferPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MktOfferPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MktOfferPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MktOfferPx";
  FIX::MktOfferPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::MktOfferPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::MktOfferPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::MktOfferPx *)new FIX::MktOfferPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MktOfferPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MktOfferPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MktOfferPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MktOfferPx.new", 
    "    MktOfferPx.new()\n"
    "    MktOfferPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MktOfferPx(FIX::MktOfferPx *arg1) {
    delete arg1;
}

swig_class SwigClassNoCapacities;

SWIGINTERN VALUE
_wrap_new_NoCapacities__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoCapacities";
  FIX::NoCapacities *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoCapacities *)new FIX::NoCapacities();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoCapacities_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoCapacities_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoCapacities);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoCapacities__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCapacities";
  FIX::NoCapacities *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoCapacities", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoCapacities", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoCapacities *)new FIX::NoCapacities((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoCapacities(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoCapacities__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoCapacities__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoCapacities.new", 
    "    NoCapacities.new()\n"
    "    NoCapacities.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoCapacities(FIX::NoCapacities *arg1) {
    delete arg1;
}

swig_class SwigClassTradeRequestType;

SWIGINTERN VALUE
_wrap_new_TradeRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestType";
  FIX::TradeRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeRequestType *)new FIX::TradeRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestType";
  FIX::TradeRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeRequestType *)new FIX::TradeRequestType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeRequestType.new", 
    "    TradeRequestType.new()\n"
    "    TradeRequestType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestType(FIX::TradeRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassNoNestedPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNestedPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartyIDs";
  FIX::NoNestedPartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNestedPartyIDs *)new FIX::NoNestedPartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNestedPartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNestedPartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNestedPartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNestedPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartyIDs";
  FIX::NoNestedPartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNestedPartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNestedPartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNestedPartyIDs *)new FIX::NoNestedPartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNestedPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNestedPartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNestedPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNestedPartyIDs.new", 
    "    NoNestedPartyIDs.new()\n"
    "    NoNestedPartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNestedPartyIDs(FIX::NoNestedPartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesStatus;

SWIGINTERN VALUE
_wrap_new_TradSesStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatus";
  FIX::TradSesStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesStatus *)new FIX::TradSesStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatus";
  FIX::TradSesStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradSesStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradSesStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradSesStatus *)new FIX::TradSesStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesStatus.new", 
    "    TradSesStatus.new()\n"
    "    TradSesStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesStatus(FIX::TradSesStatus *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingNotionalPercentageOutstanding";
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingNotionalPercentageOutstanding *)new FIX::UnderlyingNotionalPercentageOutstanding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingNotionalPercentageOutstanding_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingNotionalPercentageOutstanding_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingNotionalPercentageOutstanding";
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingNotionalPercentageOutstanding", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingNotionalPercentageOutstanding", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingNotionalPercentageOutstanding *)new FIX::UnderlyingNotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingNotionalPercentageOutstanding(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingNotionalPercentageOutstanding.new", 
    "    UnderlyingNotionalPercentageOutstanding.new()\n"
    "    UnderlyingNotionalPercentageOutstanding.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingNotionalPercentageOutstanding(FIX::UnderlyingNotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class SwigClassApplLastSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplLastSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplLastSeqNum";
  FIX::ApplLastSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplLastSeqNum *)new FIX::ApplLastSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplLastSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplLastSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplLastSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplLastSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplLastSeqNum";
  FIX::ApplLastSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::ApplLastSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::ApplLastSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::ApplLastSeqNum *)new FIX::ApplLastSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplLastSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplLastSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplLastSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplLastSeqNum.new", 
    "    ApplLastSeqNum.new()\n"
    "    ApplLastSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplLastSeqNum(FIX::ApplLastSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassPegPriceType;

SWIGINTERN VALUE
_wrap_new_PegPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegPriceType";
  FIX::PegPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegPriceType *)new FIX::PegPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegPriceType";
  FIX::PegPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PegPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PegPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PegPriceType *)new FIX::PegPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegPriceType.new", 
    "    PegPriceType.new()\n"
    "    PegPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegPriceType(FIX::PegPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassStrategyParameterName;

SWIGINTERN VALUE
_wrap_new_StrategyParameterName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterName";
  FIX::StrategyParameterName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrategyParameterName *)new FIX::StrategyParameterName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrategyParameterName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrategyParameterName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrategyParameterName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrategyParameterName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterName";
  FIX::StrategyParameterName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StrategyParameterName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StrategyParameterName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StrategyParameterName *)new FIX::StrategyParameterName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrategyParameterName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrategyParameterName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrategyParameterName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrategyParameterName.new", 
    "    StrategyParameterName.new()\n"
    "    StrategyParameterName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrategyParameterName(FIX::StrategyParameterName *arg1) {
    delete arg1;
}

swig_class SwigClassStreamAsgnRejReason;

SWIGINTERN VALUE
_wrap_new_StreamAsgnRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRejReason";
  FIX::StreamAsgnRejReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StreamAsgnRejReason *)new FIX::StreamAsgnRejReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StreamAsgnRejReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StreamAsgnRejReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StreamAsgnRejReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StreamAsgnRejReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRejReason";
  FIX::StreamAsgnRejReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StreamAsgnRejReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StreamAsgnRejReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StreamAsgnRejReason *)new FIX::StreamAsgnRejReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamAsgnRejReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StreamAsgnRejReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnRejReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StreamAsgnRejReason.new", 
    "    StreamAsgnRejReason.new()\n"
    "    StreamAsgnRejReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnRejReason(FIX::StreamAsgnRejReason *arg1) {
    delete arg1;
}

swig_class SwigClassMatchIncrement;

SWIGINTERN VALUE
_wrap_new_MatchIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MatchIncrement";
  FIX::MatchIncrement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MatchIncrement *)new FIX::MatchIncrement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MatchIncrement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MatchIncrement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MatchIncrement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MatchIncrement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchIncrement";
  FIX::MatchIncrement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MatchIncrement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MatchIncrement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MatchIncrement *)new FIX::MatchIncrement((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MatchIncrement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MatchIncrement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchIncrement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MatchIncrement.new", 
    "    MatchIncrement.new()\n"
    "    MatchIncrement.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchIncrement(FIX::MatchIncrement *arg1) {
    delete arg1;
}

swig_class SwigClassNested3PartyRole;

SWIGINTERN VALUE
_wrap_new_Nested3PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyRole";
  FIX::Nested3PartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested3PartyRole *)new FIX::Nested3PartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested3PartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested3PartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested3PartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested3PartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyRole";
  FIX::Nested3PartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Nested3PartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Nested3PartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Nested3PartyRole *)new FIX::Nested3PartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested3PartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested3PartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested3PartyRole.new", 
    "    Nested3PartyRole.new()\n"
    "    Nested3PartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartyRole(FIX::Nested3PartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingPx;

SWIGINTERN VALUE
_wrap_new_UnderlyingPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPx";
  FIX::UnderlyingPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingPx *)new FIX::UnderlyingPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPx";
  FIX::UnderlyingPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingPx *)new FIX::UnderlyingPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingPx.new", 
    "    UnderlyingPx.new()\n"
    "    UnderlyingPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPx(FIX::UnderlyingPx *arg1) {
    delete arg1;
}

swig_class SwigClassPriceImprovement;

SWIGINTERN VALUE
_wrap_new_PriceImprovement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceImprovement";
  FIX::PriceImprovement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceImprovement *)new FIX::PriceImprovement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceImprovement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceImprovement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceImprovement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceImprovement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceImprovement";
  FIX::PriceImprovement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::PriceImprovement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::PriceImprovement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::PriceImprovement *)new FIX::PriceImprovement((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceImprovement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceImprovement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceImprovement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceImprovement.new", 
    "    PriceImprovement.new()\n"
    "    PriceImprovement.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceImprovement(FIX::PriceImprovement *arg1) {
    delete arg1;
}

swig_class SwigClassValuationMethod;

SWIGINTERN VALUE
_wrap_new_ValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ValuationMethod";
  FIX::ValuationMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ValuationMethod *)new FIX::ValuationMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ValuationMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ValuationMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ValuationMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ValuationMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValuationMethod";
  FIX::ValuationMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ValuationMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ValuationMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ValuationMethod *)new FIX::ValuationMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ValuationMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ValuationMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ValuationMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ValuationMethod.new", 
    "    ValuationMethod.new()\n"
    "    ValuationMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ValuationMethod(FIX::ValuationMethod *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityID;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityID";
  FIX::DerivativeSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityID *)new FIX::DerivativeSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityID";
  FIX::DerivativeSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityID *)new FIX::DerivativeSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityID.new", 
    "    DerivativeSecurityID.new()\n"
    "    DerivativeSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityID(FIX::DerivativeSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassNoExpiration;

SWIGINTERN VALUE
_wrap_new_NoExpiration__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoExpiration";
  FIX::NoExpiration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoExpiration *)new FIX::NoExpiration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoExpiration_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoExpiration_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoExpiration);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoExpiration__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExpiration";
  FIX::NoExpiration *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoExpiration", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoExpiration", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoExpiration *)new FIX::NoExpiration((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoExpiration(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoExpiration__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoExpiration__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoExpiration.new", 
    "    NoExpiration.new()\n"
    "    NoExpiration.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoExpiration(FIX::NoExpiration *arg1) {
    delete arg1;
}

swig_class SwigClassTargetCompID;

SWIGINTERN VALUE
_wrap_new_TargetCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetCompID";
  FIX::TargetCompID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetCompID *)new FIX::TargetCompID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetCompID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetCompID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetCompID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetCompID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetCompID";
  FIX::TargetCompID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TargetCompID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TargetCompID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TargetCompID *)new FIX::TargetCompID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetCompID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetCompID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetCompID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetCompID.new", 
    "    TargetCompID.new()\n"
    "    TargetCompID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetCompID(FIX::TargetCompID *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryBuyer;

SWIGINTERN VALUE
_wrap_new_MDEntryBuyer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryBuyer";
  FIX::MDEntryBuyer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryBuyer *)new FIX::MDEntryBuyer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryBuyer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryBuyer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryBuyer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryBuyer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryBuyer";
  FIX::MDEntryBuyer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDEntryBuyer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDEntryBuyer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDEntryBuyer *)new FIX::MDEntryBuyer((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryBuyer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryBuyer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryBuyer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryBuyer.new", 
    "    MDEntryBuyer.new()\n"
    "    MDEntryBuyer.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryBuyer(FIX::MDEntryBuyer *arg1) {
    delete arg1;
}

swig_class SwigClassNoDerivativeInstrumentPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentPartySubIDs";
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDerivativeInstrumentPartySubIDs *)new FIX::NoDerivativeInstrumentPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDerivativeInstrumentPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDerivativeInstrumentPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentPartySubIDs";
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDerivativeInstrumentPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDerivativeInstrumentPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDerivativeInstrumentPartySubIDs *)new FIX::NoDerivativeInstrumentPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDerivativeInstrumentPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDerivativeInstrumentPartySubIDs.new", 
    "    NoDerivativeInstrumentPartySubIDs.new()\n"
    "    NoDerivativeInstrumentPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeInstrumentPartySubIDs(FIX::NoDerivativeInstrumentPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassNoMaturityRules;

SWIGINTERN VALUE
_wrap_new_NoMaturityRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMaturityRules";
  FIX::NoMaturityRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMaturityRules *)new FIX::NoMaturityRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMaturityRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMaturityRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMaturityRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMaturityRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMaturityRules";
  FIX::NoMaturityRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMaturityRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMaturityRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMaturityRules *)new FIX::NoMaturityRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMaturityRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMaturityRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMaturityRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMaturityRules.new", 
    "    NoMaturityRules.new()\n"
    "    NoMaturityRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMaturityRules(FIX::NoMaturityRules *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteMsgID;

SWIGINTERN VALUE
_wrap_new_QuoteMsgID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteMsgID";
  FIX::QuoteMsgID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteMsgID *)new FIX::QuoteMsgID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteMsgID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteMsgID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteMsgID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteMsgID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteMsgID";
  FIX::QuoteMsgID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteMsgID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteMsgID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteMsgID *)new FIX::QuoteMsgID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteMsgID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteMsgID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteMsgID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteMsgID.new", 
    "    QuoteMsgID.new()\n"
    "    QuoteMsgID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteMsgID(FIX::QuoteMsgID *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerType;

SWIGINTERN VALUE
_wrap_new_TriggerType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerType";
  FIX::TriggerType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerType *)new FIX::TriggerType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerType";
  FIX::TriggerType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TriggerType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TriggerType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TriggerType *)new FIX::TriggerType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerType.new", 
    "    TriggerType.new()\n"
    "    TriggerType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerType(FIX::TriggerType *arg1) {
    delete arg1;
}

swig_class SwigClassPriceProtectionScope;

SWIGINTERN VALUE
_wrap_new_PriceProtectionScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceProtectionScope";
  FIX::PriceProtectionScope *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceProtectionScope *)new FIX::PriceProtectionScope();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceProtectionScope_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceProtectionScope_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceProtectionScope);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceProtectionScope__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceProtectionScope";
  FIX::PriceProtectionScope *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::PriceProtectionScope", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::PriceProtectionScope", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::PriceProtectionScope *)new FIX::PriceProtectionScope((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceProtectionScope(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceProtectionScope__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceProtectionScope__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceProtectionScope.new", 
    "    PriceProtectionScope.new()\n"
    "    PriceProtectionScope.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceProtectionScope(FIX::PriceProtectionScope *arg1) {
    delete arg1;
}

swig_class SwigClassTotNumAssignmentReports;

SWIGINTERN VALUE
_wrap_new_TotNumAssignmentReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNumAssignmentReports";
  FIX::TotNumAssignmentReports *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNumAssignmentReports *)new FIX::TotNumAssignmentReports();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNumAssignmentReports_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNumAssignmentReports_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNumAssignmentReports);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNumAssignmentReports__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumAssignmentReports";
  FIX::TotNumAssignmentReports *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNumAssignmentReports", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNumAssignmentReports", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNumAssignmentReports *)new FIX::TotNumAssignmentReports((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNumAssignmentReports(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNumAssignmentReports__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNumAssignmentReports__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNumAssignmentReports.new", 
    "    TotNumAssignmentReports.new()\n"
    "    TotNumAssignmentReports.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNumAssignmentReports(FIX::TotNumAssignmentReports *arg1) {
    delete arg1;
}

swig_class SwigClassContraLegRefID;

SWIGINTERN VALUE
_wrap_new_ContraLegRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContraLegRefID";
  FIX::ContraLegRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContraLegRefID *)new FIX::ContraLegRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContraLegRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContraLegRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContraLegRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContraLegRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraLegRefID";
  FIX::ContraLegRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ContraLegRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ContraLegRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ContraLegRefID *)new FIX::ContraLegRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContraLegRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContraLegRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraLegRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContraLegRefID.new", 
    "    ContraLegRefID.new()\n"
    "    ContraLegRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraLegRefID(FIX::ContraLegRefID *arg1) {
    delete arg1;
}

swig_class SwigClassTradeReportRejectReason;

SWIGINTERN VALUE
_wrap_new_TradeReportRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRejectReason";
  FIX::TradeReportRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeReportRejectReason *)new FIX::TradeReportRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeReportRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeReportRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeReportRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeReportRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRejectReason";
  FIX::TradeReportRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeReportRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeReportRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeReportRejectReason *)new FIX::TradeReportRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeReportRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeReportRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeReportRejectReason.new", 
    "    TradeReportRejectReason.new()\n"
    "    TradeReportRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportRejectReason(FIX::TradeReportRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassTradeReportRefID;

SWIGINTERN VALUE
_wrap_new_TradeReportRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRefID";
  FIX::TradeReportRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeReportRefID *)new FIX::TradeReportRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeReportRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeReportRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeReportRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeReportRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRefID";
  FIX::TradeReportRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeReportRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeReportRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeReportRefID *)new FIX::TradeReportRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeReportRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeReportRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeReportRefID.new", 
    "    TradeReportRefID.new()\n"
    "    TradeReportRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportRefID(FIX::TradeReportRefID *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityListType;

SWIGINTERN VALUE
_wrap_new_SecurityListType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityListType";
  FIX::SecurityListType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityListType *)new FIX::SecurityListType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityListType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityListType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityListType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityListType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListType";
  FIX::SecurityListType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityListType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityListType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityListType *)new FIX::SecurityListType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityListType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityListType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityListType.new", 
    "    SecurityListType.new()\n"
    "    SecurityListType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListType(FIX::SecurityListType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityIDSource";
  FIX::DerivativeSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityIDSource *)new FIX::DerivativeSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityIDSource";
  FIX::DerivativeSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityIDSource *)new FIX::DerivativeSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityIDSource.new", 
    "    DerivativeSecurityIDSource.new()\n"
    "    DerivativeSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityIDSource(FIX::DerivativeSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassAssignmentUnit;

SWIGINTERN VALUE
_wrap_new_AssignmentUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AssignmentUnit";
  FIX::AssignmentUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AssignmentUnit *)new FIX::AssignmentUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AssignmentUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AssignmentUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AssignmentUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AssignmentUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AssignmentUnit";
  FIX::AssignmentUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::AssignmentUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::AssignmentUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::AssignmentUnit *)new FIX::AssignmentUnit((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AssignmentUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AssignmentUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AssignmentUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AssignmentUnit.new", 
    "    AssignmentUnit.new()\n"
    "    AssignmentUnit.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AssignmentUnit(FIX::AssignmentUnit *arg1) {
    delete arg1;
}

swig_class SwigClassTradeReportID;

SWIGINTERN VALUE
_wrap_new_TradeReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeReportID";
  FIX::TradeReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeReportID *)new FIX::TradeReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportID";
  FIX::TradeReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeReportID *)new FIX::TradeReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeReportID.new", 
    "    TradeReportID.new()\n"
    "    TradeReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportID(FIX::TradeReportID *arg1) {
    delete arg1;
}

swig_class SwigClassNoRpts;

SWIGINTERN VALUE
_wrap_new_NoRpts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRpts";
  FIX::NoRpts *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRpts *)new FIX::NoRpts();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRpts_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRpts_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRpts);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRpts__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRpts";
  FIX::NoRpts *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NoRpts", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NoRpts", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NoRpts *)new FIX::NoRpts((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRpts(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRpts__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRpts__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRpts.new", 
    "    NoRpts.new()\n"
    "    NoRpts.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRpts(FIX::NoRpts *arg1) {
    delete arg1;
}

swig_class SwigClassLegBenchmarkPriceType;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPriceType";
  FIX::LegBenchmarkPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBenchmarkPriceType *)new FIX::LegBenchmarkPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBenchmarkPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBenchmarkPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBenchmarkPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBenchmarkPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPriceType";
  FIX::LegBenchmarkPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegBenchmarkPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegBenchmarkPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegBenchmarkPriceType *)new FIX::LegBenchmarkPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBenchmarkPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBenchmarkPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBenchmarkPriceType.new", 
    "    LegBenchmarkPriceType.new()\n"
    "    LegBenchmarkPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkPriceType(FIX::LegBenchmarkPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedSubjectLen;

SWIGINTERN VALUE
_wrap_new_EncodedSubjectLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubjectLen";
  FIX::EncodedSubjectLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedSubjectLen *)new FIX::EncodedSubjectLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedSubjectLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedSubjectLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedSubjectLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedSubjectLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubjectLen";
  FIX::EncodedSubjectLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedSubjectLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedSubjectLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedSubjectLen *)new FIX::EncodedSubjectLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSubjectLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSubjectLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSubjectLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedSubjectLen.new", 
    "    EncodedSubjectLen.new()\n"
    "    EncodedSubjectLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSubjectLen(FIX::EncodedSubjectLen *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityXML;

SWIGINTERN VALUE
_wrap_new_SecurityXML__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityXML";
  FIX::SecurityXML *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityXML *)new FIX::SecurityXML();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityXML_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityXML_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityXML);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityXML__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::XMLDATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXML";
  FIX::SecurityXML *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__XMLDATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::XMLDATA const &","FIX::SecurityXML", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::XMLDATA const &","FIX::SecurityXML", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::XMLDATA * >(argp1);
  result = (FIX::SecurityXML *)new FIX::SecurityXML((FIX::XMLDATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityXML(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityXML__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__XMLDATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityXML__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityXML.new", 
    "    SecurityXML.new()\n"
    "    SecurityXML.new(FIX::XMLDATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityXML(FIX::SecurityXML *arg1) {
    delete arg1;
}

swig_class SwigClassLegReportID;

SWIGINTERN VALUE
_wrap_new_LegReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegReportID";
  FIX::LegReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegReportID *)new FIX::LegReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegReportID";
  FIX::LegReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegReportID *)new FIX::LegReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegReportID.new", 
    "    LegReportID.new()\n"
    "    LegReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegReportID(FIX::LegReportID *arg1) {
    delete arg1;
}

swig_class SwigClassNested3PartySubIDType;

SWIGINTERN VALUE
_wrap_new_Nested3PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubIDType";
  FIX::Nested3PartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested3PartySubIDType *)new FIX::Nested3PartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested3PartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested3PartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested3PartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested3PartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubIDType";
  FIX::Nested3PartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Nested3PartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Nested3PartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Nested3PartySubIDType *)new FIX::Nested3PartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested3PartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested3PartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested3PartySubIDType.new", 
    "    Nested3PartySubIDType.new()\n"
    "    Nested3PartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartySubIDType(FIX::Nested3PartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_BenchmarkSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityIDSource";
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkSecurityIDSource *)new FIX::BenchmarkSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityIDSource";
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BenchmarkSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BenchmarkSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BenchmarkSecurityIDSource *)new FIX::BenchmarkSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkSecurityIDSource.new", 
    "    BenchmarkSecurityIDSource.new()\n"
    "    BenchmarkSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkSecurityIDSource(FIX::BenchmarkSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteRejectReason;

SWIGINTERN VALUE
_wrap_new_QuoteRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteRejectReason";
  FIX::QuoteRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteRejectReason *)new FIX::QuoteRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRejectReason";
  FIX::QuoteRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteRejectReason *)new FIX::QuoteRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteRejectReason.new", 
    "    QuoteRejectReason.new()\n"
    "    QuoteRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRejectReason(FIX::QuoteRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassHeartBtInt;

SWIGINTERN VALUE
_wrap_new_HeartBtInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HeartBtInt";
  FIX::HeartBtInt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HeartBtInt *)new FIX::HeartBtInt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HeartBtInt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HeartBtInt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HeartBtInt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HeartBtInt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HeartBtInt";
  FIX::HeartBtInt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::HeartBtInt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::HeartBtInt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::HeartBtInt *)new FIX::HeartBtInt((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HeartBtInt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HeartBtInt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HeartBtInt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HeartBtInt.new", 
    "    HeartBtInt.new()\n"
    "    HeartBtInt.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HeartBtInt(FIX::HeartBtInt *arg1) {
    delete arg1;
}

swig_class SwigClassBidForwardPoints;

SWIGINTERN VALUE
_wrap_new_BidForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints";
  FIX::BidForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidForwardPoints *)new FIX::BidForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints";
  FIX::BidForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::BidForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::BidForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::BidForwardPoints *)new FIX::BidForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidForwardPoints.new", 
    "    BidForwardPoints.new()\n"
    "    BidForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidForwardPoints(FIX::BidForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassPossResend;

SWIGINTERN VALUE
_wrap_new_PossResend__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PossResend";
  FIX::PossResend *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PossResend *)new FIX::PossResend();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PossResend_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PossResend_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PossResend);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PossResend__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PossResend";
  FIX::PossResend *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PossResend", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PossResend", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PossResend *)new FIX::PossResend((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PossResend(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PossResend__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PossResend__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PossResend.new", 
    "    PossResend.new()\n"
    "    PossResend.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PossResend(FIX::PossResend *arg1) {
    delete arg1;
}

swig_class SwigClassSymbol;

SWIGINTERN VALUE
_wrap_new_Symbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Symbol";
  FIX::Symbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Symbol *)new FIX::Symbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Symbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Symbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Symbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Symbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Symbol";
  FIX::Symbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Symbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Symbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Symbol *)new FIX::Symbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Symbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Symbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Symbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Symbol.new", 
    "    Symbol.new()\n"
    "    Symbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Symbol(FIX::Symbol *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedUnderlyingSecurityDesc;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDesc";
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedUnderlyingSecurityDesc *)new FIX::EncodedUnderlyingSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedUnderlyingSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedUnderlyingSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDesc";
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedUnderlyingSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedUnderlyingSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedUnderlyingSecurityDesc *)new FIX::EncodedUnderlyingSecurityDesc((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedUnderlyingSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedUnderlyingSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedUnderlyingSecurityDesc.new", 
    "    EncodedUnderlyingSecurityDesc.new()\n"
    "    EncodedUnderlyingSecurityDesc.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingSecurityDesc(FIX::EncodedUnderlyingSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassMarketReportID;

SWIGINTERN VALUE
_wrap_new_MarketReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketReportID";
  FIX::MarketReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketReportID *)new FIX::MarketReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketReportID";
  FIX::MarketReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MarketReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MarketReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MarketReportID *)new FIX::MarketReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketReportID.new", 
    "    MarketReportID.new()\n"
    "    MarketReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketReportID(FIX::MarketReportID *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionPrice;

SWIGINTERN VALUE
_wrap_new_DiscretionPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionPrice";
  FIX::DiscretionPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionPrice *)new FIX::DiscretionPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionPrice";
  FIX::DiscretionPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::DiscretionPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::DiscretionPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::DiscretionPrice *)new FIX::DiscretionPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionPrice.new", 
    "    DiscretionPrice.new()\n"
    "    DiscretionPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionPrice(FIX::DiscretionPrice *arg1) {
    delete arg1;
}

swig_class SwigClassContAmtValue;

SWIGINTERN VALUE
_wrap_new_ContAmtValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContAmtValue";
  FIX::ContAmtValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContAmtValue *)new FIX::ContAmtValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContAmtValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContAmtValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContAmtValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContAmtValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtValue";
  FIX::ContAmtValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::ContAmtValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::ContAmtValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::ContAmtValue *)new FIX::ContAmtValue((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContAmtValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContAmtValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContAmtValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContAmtValue.new", 
    "    ContAmtValue.new()\n"
    "    ContAmtValue.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContAmtValue(FIX::ContAmtValue *arg1) {
    delete arg1;
}

swig_class SwigClassQuantityType;

SWIGINTERN VALUE
_wrap_new_QuantityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuantityType";
  FIX::QuantityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuantityType *)new FIX::QuantityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuantityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuantityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuantityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuantityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuantityType";
  FIX::QuantityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuantityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuantityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuantityType *)new FIX::QuantityType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuantityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuantityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuantityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuantityType.new", 
    "    QuantityType.new()\n"
    "    QuantityType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuantityType(FIX::QuantityType *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventPriceBoundaryMethod;

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceBoundaryMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryMethod";
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventPriceBoundaryMethod *)new FIX::ComplexEventPriceBoundaryMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventPriceBoundaryMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceBoundaryMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryMethod";
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ComplexEventPriceBoundaryMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ComplexEventPriceBoundaryMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ComplexEventPriceBoundaryMethod *)new FIX::ComplexEventPriceBoundaryMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventPriceBoundaryMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventPriceBoundaryMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPriceBoundaryMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventPriceBoundaryMethod.new", 
    "    ComplexEventPriceBoundaryMethod.new()\n"
    "    ComplexEventPriceBoundaryMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPriceBoundaryMethod(FIX::ComplexEventPriceBoundaryMethod *arg1) {
    delete arg1;
}

swig_class SwigClassImpliedMarketIndicator;

SWIGINTERN VALUE
_wrap_new_ImpliedMarketIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ImpliedMarketIndicator";
  FIX::ImpliedMarketIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ImpliedMarketIndicator *)new FIX::ImpliedMarketIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ImpliedMarketIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ImpliedMarketIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ImpliedMarketIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ImpliedMarketIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ImpliedMarketIndicator";
  FIX::ImpliedMarketIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ImpliedMarketIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ImpliedMarketIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ImpliedMarketIndicator *)new FIX::ImpliedMarketIndicator((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ImpliedMarketIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ImpliedMarketIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ImpliedMarketIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ImpliedMarketIndicator.new", 
    "    ImpliedMarketIndicator.new()\n"
    "    ImpliedMarketIndicator.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ImpliedMarketIndicator(FIX::ImpliedMarketIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassAllocClearingFeeIndicator;

SWIGINTERN VALUE
_wrap_new_AllocClearingFeeIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocClearingFeeIndicator";
  FIX::AllocClearingFeeIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocClearingFeeIndicator *)new FIX::AllocClearingFeeIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocClearingFeeIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocClearingFeeIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocClearingFeeIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocClearingFeeIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocClearingFeeIndicator";
  FIX::AllocClearingFeeIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocClearingFeeIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocClearingFeeIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocClearingFeeIndicator *)new FIX::AllocClearingFeeIndicator((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocClearingFeeIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocClearingFeeIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocClearingFeeIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocClearingFeeIndicator.new", 
    "    AllocClearingFeeIndicator.new()\n"
    "    AllocClearingFeeIndicator.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocClearingFeeIndicator(FIX::AllocClearingFeeIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteRequestType;

SWIGINTERN VALUE
_wrap_new_QuoteRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestType";
  FIX::QuoteRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteRequestType *)new FIX::QuoteRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestType";
  FIX::QuoteRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteRequestType *)new FIX::QuoteRequestType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteRequestType.new", 
    "    QuoteRequestType.new()\n"
    "    QuoteRequestType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRequestType(FIX::QuoteRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityRequestResult;

SWIGINTERN VALUE
_wrap_new_SecurityRequestResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestResult";
  FIX::SecurityRequestResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityRequestResult *)new FIX::SecurityRequestResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityRequestResult_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityRequestResult_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityRequestResult);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityRequestResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestResult";
  FIX::SecurityRequestResult *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityRequestResult", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityRequestResult", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityRequestResult *)new FIX::SecurityRequestResult((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityRequestResult(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityRequestResult__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityRequestResult__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityRequestResult.new", 
    "    SecurityRequestResult.new()\n"
    "    SecurityRequestResult.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityRequestResult(FIX::SecurityRequestResult *arg1) {
    delete arg1;
}

swig_class SwigClassOrderRestrictions;

SWIGINTERN VALUE
_wrap_new_OrderRestrictions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderRestrictions";
  FIX::OrderRestrictions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderRestrictions *)new FIX::OrderRestrictions();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderRestrictions_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderRestrictions_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderRestrictions);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderRestrictions__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderRestrictions";
  FIX::OrderRestrictions *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::OrderRestrictions", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::OrderRestrictions", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::OrderRestrictions *)new FIX::OrderRestrictions((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderRestrictions(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderRestrictions__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderRestrictions__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderRestrictions.new", 
    "    OrderRestrictions.new()\n"
    "    OrderRestrictions.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderRestrictions(FIX::OrderRestrictions *arg1) {
    delete arg1;
}

swig_class SwigClassNoSideTrdRegTS;

SWIGINTERN VALUE
_wrap_new_NoSideTrdRegTS__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSideTrdRegTS";
  FIX::NoSideTrdRegTS *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSideTrdRegTS *)new FIX::NoSideTrdRegTS();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSideTrdRegTS_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSideTrdRegTS_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSideTrdRegTS);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSideTrdRegTS__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSideTrdRegTS";
  FIX::NoSideTrdRegTS *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSideTrdRegTS", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSideTrdRegTS", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSideTrdRegTS *)new FIX::NoSideTrdRegTS((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSideTrdRegTS(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSideTrdRegTS__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSideTrdRegTS__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSideTrdRegTS.new", 
    "    NoSideTrdRegTS.new()\n"
    "    NoSideTrdRegTS.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSideTrdRegTS(FIX::NoSideTrdRegTS *arg1) {
    delete arg1;
}

swig_class SwigClassText;

SWIGINTERN VALUE
_wrap_new_Text__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Text";
  FIX::Text *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Text *)new FIX::Text();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Text_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Text_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Text);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Text__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Text";
  FIX::Text *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Text", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Text", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Text *)new FIX::Text((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Text(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Text__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Text__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Text.new", 
    "    Text.new()\n"
    "    Text.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Text(FIX::Text *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedTextLen;

SWIGINTERN VALUE
_wrap_new_EncodedTextLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedTextLen";
  FIX::EncodedTextLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedTextLen *)new FIX::EncodedTextLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedTextLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedTextLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedTextLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedTextLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedTextLen";
  FIX::EncodedTextLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedTextLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedTextLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedTextLen *)new FIX::EncodedTextLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedTextLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedTextLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedTextLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedTextLen.new", 
    "    EncodedTextLen.new()\n"
    "    EncodedTextLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedTextLen(FIX::EncodedTextLen *arg1) {
    delete arg1;
}

swig_class SwigClassListExecInstType;

SWIGINTERN VALUE
_wrap_new_ListExecInstType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListExecInstType";
  FIX::ListExecInstType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListExecInstType *)new FIX::ListExecInstType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListExecInstType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListExecInstType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListExecInstType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListExecInstType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListExecInstType";
  FIX::ListExecInstType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ListExecInstType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ListExecInstType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ListExecInstType *)new FIX::ListExecInstType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListExecInstType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListExecInstType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListExecInstType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListExecInstType.new", 
    "    ListExecInstType.new()\n"
    "    ListExecInstType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListExecInstType(FIX::ListExecInstType *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryOrderID;

SWIGINTERN VALUE
_wrap_new_SecondaryOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryOrderID";
  FIX::SecondaryOrderID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryOrderID *)new FIX::SecondaryOrderID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryOrderID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryOrderID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryOrderID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryOrderID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryOrderID";
  FIX::SecondaryOrderID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryOrderID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryOrderID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryOrderID *)new FIX::SecondaryOrderID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryOrderID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryOrderID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryOrderID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryOrderID.new", 
    "    SecondaryOrderID.new()\n"
    "    SecondaryOrderID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryOrderID(FIX::SecondaryOrderID *arg1) {
    delete arg1;
}

swig_class SwigClassExecBroker;

SWIGINTERN VALUE
_wrap_new_ExecBroker__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecBroker";
  FIX::ExecBroker *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecBroker *)new FIX::ExecBroker();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecBroker_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecBroker_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecBroker);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecBroker__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecBroker";
  FIX::ExecBroker *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ExecBroker", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ExecBroker", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ExecBroker *)new FIX::ExecBroker((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecBroker(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecBroker__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecBroker__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecBroker.new", 
    "    ExecBroker.new()\n"
    "    ExecBroker.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecBroker(FIX::ExecBroker *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityXMLLen;

SWIGINTERN VALUE
_wrap_new_SecurityXMLLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLLen";
  FIX::SecurityXMLLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityXMLLen *)new FIX::SecurityXMLLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityXMLLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityXMLLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityXMLLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityXMLLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLLen";
  FIX::SecurityXMLLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::SecurityXMLLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::SecurityXMLLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::SecurityXMLLen *)new FIX::SecurityXMLLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityXMLLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityXMLLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityXMLLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityXMLLen.new", 
    "    SecurityXMLLen.new()\n"
    "    SecurityXMLLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityXMLLen(FIX::SecurityXMLLen *arg1) {
    delete arg1;
}

swig_class SwigClassApplSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplSeqNum";
  FIX::ApplSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplSeqNum *)new FIX::ApplSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplSeqNum";
  FIX::ApplSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::ApplSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::ApplSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::ApplSeqNum *)new FIX::ApplSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplSeqNum.new", 
    "    ApplSeqNum.new()\n"
    "    ApplSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplSeqNum(FIX::ApplSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassMaxTradeVol;

SWIGINTERN VALUE
_wrap_new_MaxTradeVol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaxTradeVol";
  FIX::MaxTradeVol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaxTradeVol *)new FIX::MaxTradeVol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaxTradeVol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaxTradeVol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaxTradeVol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaxTradeVol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxTradeVol";
  FIX::MaxTradeVol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MaxTradeVol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MaxTradeVol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MaxTradeVol *)new FIX::MaxTradeVol((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaxTradeVol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaxTradeVol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxTradeVol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaxTradeVol.new", 
    "    MaxTradeVol.new()\n"
    "    MaxTradeVol.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxTradeVol(FIX::MaxTradeVol *arg1) {
    delete arg1;
}

swig_class SwigClassOfferSwapPoints;

SWIGINTERN VALUE
_wrap_new_OfferSwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferSwapPoints";
  FIX::OfferSwapPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferSwapPoints *)new FIX::OfferSwapPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferSwapPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferSwapPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferSwapPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferSwapPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSwapPoints";
  FIX::OfferSwapPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::OfferSwapPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::OfferSwapPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::OfferSwapPoints *)new FIX::OfferSwapPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferSwapPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferSwapPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferSwapPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferSwapPoints.new", 
    "    OfferSwapPoints.new()\n"
    "    OfferSwapPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferSwapPoints(FIX::OfferSwapPoints *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPartySubIDType;

SWIGINTERN VALUE
_wrap_new_SettlPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubIDType";
  FIX::SettlPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPartySubIDType *)new FIX::SettlPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubIDType";
  FIX::SettlPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlPartySubIDType *)new FIX::SettlPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPartySubIDType.new", 
    "    SettlPartySubIDType.new()\n"
    "    SettlPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartySubIDType(FIX::SettlPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassDistribPaymentMethod;

SWIGINTERN VALUE
_wrap_new_DistribPaymentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DistribPaymentMethod";
  FIX::DistribPaymentMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DistribPaymentMethod *)new FIX::DistribPaymentMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DistribPaymentMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DistribPaymentMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DistribPaymentMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DistribPaymentMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DistribPaymentMethod";
  FIX::DistribPaymentMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DistribPaymentMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DistribPaymentMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DistribPaymentMethod *)new FIX::DistribPaymentMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DistribPaymentMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DistribPaymentMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DistribPaymentMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DistribPaymentMethod.new", 
    "    DistribPaymentMethod.new()\n"
    "    DistribPaymentMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DistribPaymentMethod(FIX::DistribPaymentMethod *arg1) {
    delete arg1;
}

swig_class SwigClassTotalAffectedOrders;

SWIGINTERN VALUE
_wrap_new_TotalAffectedOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalAffectedOrders";
  FIX::TotalAffectedOrders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalAffectedOrders *)new FIX::TotalAffectedOrders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalAffectedOrders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalAffectedOrders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalAffectedOrders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalAffectedOrders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalAffectedOrders";
  FIX::TotalAffectedOrders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotalAffectedOrders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotalAffectedOrders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotalAffectedOrders *)new FIX::TotalAffectedOrders((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalAffectedOrders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalAffectedOrders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalAffectedOrders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalAffectedOrders.new", 
    "    TotalAffectedOrders.new()\n"
    "    TotalAffectedOrders.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalAffectedOrders(FIX::TotalAffectedOrders *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeIncrement;

SWIGINTERN VALUE
_wrap_new_StrikeIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeIncrement";
  FIX::StrikeIncrement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeIncrement *)new FIX::StrikeIncrement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeIncrement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeIncrement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeIncrement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeIncrement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeIncrement";
  FIX::StrikeIncrement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::StrikeIncrement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::StrikeIncrement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::StrikeIncrement *)new FIX::StrikeIncrement((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeIncrement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeIncrement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeIncrement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikeIncrement.new", 
    "    StrikeIncrement.new()\n"
    "    StrikeIncrement.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeIncrement(FIX::StrikeIncrement *arg1) {
    delete arg1;
}

swig_class SwigClassOrderHandlingInstSource;

SWIGINTERN VALUE
_wrap_new_OrderHandlingInstSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderHandlingInstSource";
  FIX::OrderHandlingInstSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderHandlingInstSource *)new FIX::OrderHandlingInstSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderHandlingInstSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderHandlingInstSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderHandlingInstSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderHandlingInstSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderHandlingInstSource";
  FIX::OrderHandlingInstSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OrderHandlingInstSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OrderHandlingInstSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OrderHandlingInstSource *)new FIX::OrderHandlingInstSource((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderHandlingInstSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderHandlingInstSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderHandlingInstSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderHandlingInstSource.new", 
    "    OrderHandlingInstSource.new()\n"
    "    OrderHandlingInstSource.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderHandlingInstSource(FIX::OrderHandlingInstSource *arg1) {
    delete arg1;
}

swig_class SwigClassCopyMsgIndicator;

SWIGINTERN VALUE
_wrap_new_CopyMsgIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CopyMsgIndicator";
  FIX::CopyMsgIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CopyMsgIndicator *)new FIX::CopyMsgIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CopyMsgIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CopyMsgIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CopyMsgIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CopyMsgIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CopyMsgIndicator";
  FIX::CopyMsgIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::CopyMsgIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::CopyMsgIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::CopyMsgIndicator *)new FIX::CopyMsgIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CopyMsgIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CopyMsgIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CopyMsgIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CopyMsgIndicator.new", 
    "    CopyMsgIndicator.new()\n"
    "    CopyMsgIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CopyMsgIndicator(FIX::CopyMsgIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassNoDlvyInst;

SWIGINTERN VALUE
_wrap_new_NoDlvyInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDlvyInst";
  FIX::NoDlvyInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDlvyInst *)new FIX::NoDlvyInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDlvyInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDlvyInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDlvyInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDlvyInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDlvyInst";
  FIX::NoDlvyInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDlvyInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDlvyInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDlvyInst *)new FIX::NoDlvyInst((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDlvyInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDlvyInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDlvyInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDlvyInst.new", 
    "    NoDlvyInst.new()\n"
    "    NoDlvyInst.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDlvyInst(FIX::NoDlvyInst *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteEntryID;

SWIGINTERN VALUE
_wrap_new_QuoteEntryID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryID";
  FIX::QuoteEntryID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteEntryID *)new FIX::QuoteEntryID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteEntryID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteEntryID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteEntryID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteEntryID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryID";
  FIX::QuoteEntryID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteEntryID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteEntryID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteEntryID *)new FIX::QuoteEntryID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteEntryID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteEntryID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteEntryID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteEntryID.new", 
    "    QuoteEntryID.new()\n"
    "    QuoteEntryID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteEntryID(FIX::QuoteEntryID *arg1) {
    delete arg1;
}

swig_class SwigClassAffirmStatus;

SWIGINTERN VALUE
_wrap_new_AffirmStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AffirmStatus";
  FIX::AffirmStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AffirmStatus *)new FIX::AffirmStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AffirmStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AffirmStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AffirmStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AffirmStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffirmStatus";
  FIX::AffirmStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AffirmStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AffirmStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AffirmStatus *)new FIX::AffirmStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AffirmStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AffirmStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AffirmStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AffirmStatus.new", 
    "    AffirmStatus.new()\n"
    "    AffirmStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AffirmStatus(FIX::AffirmStatus *arg1) {
    delete arg1;
}

swig_class SwigClassMailingInst;

SWIGINTERN VALUE
_wrap_new_MailingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MailingInst";
  FIX::MailingInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MailingInst *)new FIX::MailingInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MailingInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MailingInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MailingInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MailingInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MailingInst";
  FIX::MailingInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MailingInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MailingInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MailingInst *)new FIX::MailingInst((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MailingInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MailingInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MailingInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MailingInst.new", 
    "    MailingInst.new()\n"
    "    MailingInst.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MailingInst(FIX::MailingInst *arg1) {
    delete arg1;
}

swig_class SwigClassOfferSize;

SWIGINTERN VALUE
_wrap_new_OfferSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferSize";
  FIX::OfferSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferSize *)new FIX::OfferSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSize";
  FIX::OfferSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::OfferSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::OfferSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::OfferSize *)new FIX::OfferSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferSize.new", 
    "    OfferSize.new()\n"
    "    OfferSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferSize(FIX::OfferSize *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityType;

SWIGINTERN VALUE
_wrap_new_LegSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityType";
  FIX::LegSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityType *)new FIX::LegSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityType";
  FIX::LegSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecurityType *)new FIX::LegSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityType.new", 
    "    LegSecurityType.new()\n"
    "    LegSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityType(FIX::LegSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassOrigCustOrderCapacity;

SWIGINTERN VALUE
_wrap_new_OrigCustOrderCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigCustOrderCapacity";
  FIX::OrigCustOrderCapacity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigCustOrderCapacity *)new FIX::OrigCustOrderCapacity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigCustOrderCapacity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigCustOrderCapacity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigCustOrderCapacity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigCustOrderCapacity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigCustOrderCapacity";
  FIX::OrigCustOrderCapacity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OrigCustOrderCapacity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OrigCustOrderCapacity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OrigCustOrderCapacity *)new FIX::OrigCustOrderCapacity((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigCustOrderCapacity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigCustOrderCapacity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigCustOrderCapacity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigCustOrderCapacity.new", 
    "    OrigCustOrderCapacity.new()\n"
    "    OrigCustOrderCapacity.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigCustOrderCapacity(FIX::OrigCustOrderCapacity *arg1) {
    delete arg1;
}

swig_class SwigClassAllocMethod;

SWIGINTERN VALUE
_wrap_new_AllocMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocMethod";
  FIX::AllocMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocMethod *)new FIX::AllocMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocMethod";
  FIX::AllocMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocMethod *)new FIX::AllocMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocMethod.new", 
    "    AllocMethod.new()\n"
    "    AllocMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocMethod(FIX::AllocMethod *arg1) {
    delete arg1;
}

swig_class SwigClassQuantityDate;

SWIGINTERN VALUE
_wrap_new_QuantityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuantityDate";
  FIX::QuantityDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuantityDate *)new FIX::QuantityDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuantityDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuantityDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuantityDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuantityDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuantityDate";
  FIX::QuantityDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::QuantityDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::QuantityDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::QuantityDate *)new FIX::QuantityDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuantityDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuantityDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuantityDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuantityDate.new", 
    "    QuantityDate.new()\n"
    "    QuantityDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuantityDate(FIX::QuantityDate *arg1) {
    delete arg1;
}

swig_class SwigClassTargetStrategyPerformance;

SWIGINTERN VALUE
_wrap_new_TargetStrategyPerformance__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyPerformance";
  FIX::TargetStrategyPerformance *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetStrategyPerformance *)new FIX::TargetStrategyPerformance();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetStrategyPerformance_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetStrategyPerformance_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetStrategyPerformance);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetStrategyPerformance__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyPerformance";
  FIX::TargetStrategyPerformance *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::TargetStrategyPerformance", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::TargetStrategyPerformance", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::TargetStrategyPerformance *)new FIX::TargetStrategyPerformance((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetStrategyPerformance(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetStrategyPerformance__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetStrategyPerformance__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetStrategyPerformance.new", 
    "    TargetStrategyPerformance.new()\n"
    "    TargetStrategyPerformance.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetStrategyPerformance(FIX::TargetStrategyPerformance *arg1) {
    delete arg1;
}

swig_class SwigClassCardExpDate;

SWIGINTERN VALUE
_wrap_new_CardExpDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CardExpDate";
  FIX::CardExpDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CardExpDate *)new FIX::CardExpDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CardExpDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CardExpDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CardExpDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CardExpDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardExpDate";
  FIX::CardExpDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::CardExpDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::CardExpDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::CardExpDate *)new FIX::CardExpDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CardExpDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CardExpDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardExpDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CardExpDate.new", 
    "    CardExpDate.new()\n"
    "    CardExpDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CardExpDate(FIX::CardExpDate *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmID;

SWIGINTERN VALUE
_wrap_new_ConfirmID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmID";
  FIX::ConfirmID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmID *)new FIX::ConfirmID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmID";
  FIX::ConfirmID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ConfirmID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ConfirmID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ConfirmID *)new FIX::ConfirmID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmID.new", 
    "    ConfirmID.new()\n"
    "    ConfirmID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmID(FIX::ConfirmID *arg1) {
    delete arg1;
}

swig_class SwigClassStandInstDbName;

SWIGINTERN VALUE
_wrap_new_StandInstDbName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbName";
  FIX::StandInstDbName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StandInstDbName *)new FIX::StandInstDbName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StandInstDbName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StandInstDbName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StandInstDbName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StandInstDbName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbName";
  FIX::StandInstDbName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StandInstDbName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StandInstDbName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StandInstDbName *)new FIX::StandInstDbName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StandInstDbName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StandInstDbName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StandInstDbName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StandInstDbName.new", 
    "    StandInstDbName.new()\n"
    "    StandInstDbName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StandInstDbName(FIX::StandInstDbName *arg1) {
    delete arg1;
}

swig_class SwigClassDayOrderQty;

SWIGINTERN VALUE
_wrap_new_DayOrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DayOrderQty";
  FIX::DayOrderQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DayOrderQty *)new FIX::DayOrderQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DayOrderQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DayOrderQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DayOrderQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DayOrderQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayOrderQty";
  FIX::DayOrderQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DayOrderQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DayOrderQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DayOrderQty *)new FIX::DayOrderQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DayOrderQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DayOrderQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayOrderQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DayOrderQty.new", 
    "    DayOrderQty.new()\n"
    "    DayOrderQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DayOrderQty(FIX::DayOrderQty *arg1) {
    delete arg1;
}

swig_class SwigClassHighLimitPrice;

SWIGINTERN VALUE
_wrap_new_HighLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HighLimitPrice";
  FIX::HighLimitPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HighLimitPrice *)new FIX::HighLimitPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HighLimitPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HighLimitPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HighLimitPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HighLimitPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HighLimitPrice";
  FIX::HighLimitPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::HighLimitPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::HighLimitPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::HighLimitPrice *)new FIX::HighLimitPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HighLimitPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HighLimitPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighLimitPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HighLimitPrice.new", 
    "    HighLimitPrice.new()\n"
    "    HighLimitPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HighLimitPrice(FIX::HighLimitPrice *arg1) {
    delete arg1;
}

swig_class SwigClassFirmTradeID;

SWIGINTERN VALUE
_wrap_new_FirmTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FirmTradeID";
  FIX::FirmTradeID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FirmTradeID *)new FIX::FirmTradeID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FirmTradeID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FirmTradeID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FirmTradeID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FirmTradeID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FirmTradeID";
  FIX::FirmTradeID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::FirmTradeID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::FirmTradeID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::FirmTradeID *)new FIX::FirmTradeID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FirmTradeID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FirmTradeID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FirmTradeID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FirmTradeID.new", 
    "    FirmTradeID.new()\n"
    "    FirmTradeID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FirmTradeID(FIX::FirmTradeID *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryIndividualAllocID;

SWIGINTERN VALUE
_wrap_new_SecondaryIndividualAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryIndividualAllocID";
  FIX::SecondaryIndividualAllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryIndividualAllocID *)new FIX::SecondaryIndividualAllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryIndividualAllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryIndividualAllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryIndividualAllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryIndividualAllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryIndividualAllocID";
  FIX::SecondaryIndividualAllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryIndividualAllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryIndividualAllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryIndividualAllocID *)new FIX::SecondaryIndividualAllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryIndividualAllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryIndividualAllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryIndividualAllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryIndividualAllocID.new", 
    "    SecondaryIndividualAllocID.new()\n"
    "    SecondaryIndividualAllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryIndividualAllocID(FIX::SecondaryIndividualAllocID *arg1) {
    delete arg1;
}

swig_class SwigClassAgreementDesc;

SWIGINTERN VALUE
_wrap_new_AgreementDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AgreementDesc";
  FIX::AgreementDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AgreementDesc *)new FIX::AgreementDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AgreementDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AgreementDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AgreementDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AgreementDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementDesc";
  FIX::AgreementDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AgreementDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AgreementDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AgreementDesc *)new FIX::AgreementDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AgreementDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AgreementDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AgreementDesc.new", 
    "    AgreementDesc.new()\n"
    "    AgreementDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementDesc(FIX::AgreementDesc *arg1) {
    delete arg1;
}

swig_class SwigClassMassCancelResponse;

SWIGINTERN VALUE
_wrap_new_MassCancelResponse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassCancelResponse";
  FIX::MassCancelResponse *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassCancelResponse *)new FIX::MassCancelResponse();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassCancelResponse_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassCancelResponse_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassCancelResponse);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassCancelResponse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelResponse";
  FIX::MassCancelResponse *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MassCancelResponse", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MassCancelResponse", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MassCancelResponse *)new FIX::MassCancelResponse((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassCancelResponse(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassCancelResponse__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassCancelResponse__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassCancelResponse.new", 
    "    MassCancelResponse.new()\n"
    "    MassCancelResponse.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassCancelResponse(FIX::MassCancelResponse *arg1) {
    delete arg1;
}

swig_class SwigClassLegSettlCurrency;

SWIGINTERN VALUE
_wrap_new_LegSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSettlCurrency";
  FIX::LegSettlCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSettlCurrency *)new FIX::LegSettlCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSettlCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSettlCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSettlCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSettlCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlCurrency";
  FIX::LegSettlCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::LegSettlCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::LegSettlCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::LegSettlCurrency *)new FIX::LegSettlCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSettlCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSettlCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSettlCurrency.new", 
    "    LegSettlCurrency.new()\n"
    "    LegSettlCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlCurrency(FIX::LegSettlCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassCommission;

SWIGINTERN VALUE
_wrap_new_Commission__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Commission";
  FIX::Commission *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Commission *)new FIX::Commission();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Commission_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Commission_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Commission);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Commission__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Commission";
  FIX::Commission *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::Commission", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::Commission", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::Commission *)new FIX::Commission((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Commission(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Commission__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Commission__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Commission.new", 
    "    Commission.new()\n"
    "    Commission.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Commission(FIX::Commission *arg1) {
    delete arg1;
}

swig_class SwigClassStreamAsgnReqType;

SWIGINTERN VALUE
_wrap_new_StreamAsgnReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqType";
  FIX::StreamAsgnReqType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StreamAsgnReqType *)new FIX::StreamAsgnReqType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StreamAsgnReqType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StreamAsgnReqType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StreamAsgnReqType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StreamAsgnReqType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqType";
  FIX::StreamAsgnReqType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StreamAsgnReqType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StreamAsgnReqType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StreamAsgnReqType *)new FIX::StreamAsgnReqType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamAsgnReqType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StreamAsgnReqType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnReqType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StreamAsgnReqType.new", 
    "    StreamAsgnReqType.new()\n"
    "    StreamAsgnReqType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnReqType(FIX::StreamAsgnReqType *arg1) {
    delete arg1;
}

swig_class SwigClassBidSwapPoints;

SWIGINTERN VALUE
_wrap_new_BidSwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidSwapPoints";
  FIX::BidSwapPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidSwapPoints *)new FIX::BidSwapPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidSwapPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidSwapPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidSwapPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidSwapPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSwapPoints";
  FIX::BidSwapPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::BidSwapPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::BidSwapPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::BidSwapPoints *)new FIX::BidSwapPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidSwapPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidSwapPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidSwapPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidSwapPoints.new", 
    "    BidSwapPoints.new()\n"
    "    BidSwapPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidSwapPoints(FIX::BidSwapPoints *arg1) {
    delete arg1;
}

swig_class SwigClassNoSettlPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoSettlPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartyIDs";
  FIX::NoSettlPartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSettlPartyIDs *)new FIX::NoSettlPartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSettlPartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSettlPartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSettlPartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSettlPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartyIDs";
  FIX::NoSettlPartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSettlPartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSettlPartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSettlPartyIDs *)new FIX::NoSettlPartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSettlPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSettlPartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSettlPartyIDs.new", 
    "    NoSettlPartyIDs.new()\n"
    "    NoSettlPartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlPartyIDs(FIX::NoSettlPartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassSymbolSfx;

SWIGINTERN VALUE
_wrap_new_SymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SymbolSfx";
  FIX::SymbolSfx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SymbolSfx *)new FIX::SymbolSfx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SymbolSfx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SymbolSfx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SymbolSfx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SymbolSfx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SymbolSfx";
  FIX::SymbolSfx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SymbolSfx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SymbolSfx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SymbolSfx *)new FIX::SymbolSfx((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SymbolSfx.new", 
    "    SymbolSfx.new()\n"
    "    SymbolSfx.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SymbolSfx(FIX::SymbolSfx *arg1) {
    delete arg1;
}

swig_class SwigClassBusinessRejectRefID;

SWIGINTERN VALUE
_wrap_new_BusinessRejectRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectRefID";
  FIX::BusinessRejectRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BusinessRejectRefID *)new FIX::BusinessRejectRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BusinessRejectRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BusinessRejectRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BusinessRejectRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BusinessRejectRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectRefID";
  FIX::BusinessRejectRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BusinessRejectRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BusinessRejectRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BusinessRejectRefID *)new FIX::BusinessRejectRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BusinessRejectRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BusinessRejectRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BusinessRejectRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BusinessRejectRefID.new", 
    "    BusinessRejectRefID.new()\n"
    "    BusinessRejectRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BusinessRejectRefID(FIX::BusinessRejectRefID *arg1) {
    delete arg1;
}

swig_class SwigClassPrice2;

SWIGINTERN VALUE
_wrap_new_Price2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Price2";
  FIX::Price2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Price2 *)new FIX::Price2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Price2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Price2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Price2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Price2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Price2";
  FIX::Price2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::Price2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::Price2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::Price2 *)new FIX::Price2((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Price2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Price2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Price2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Price2.new", 
    "    Price2.new()\n"
    "    Price2.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Price2(FIX::Price2 *arg1) {
    delete arg1;
}

swig_class SwigClassFillLiquidityInd;

SWIGINTERN VALUE
_wrap_new_FillLiquidityInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FillLiquidityInd";
  FIX::FillLiquidityInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FillLiquidityInd *)new FIX::FillLiquidityInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FillLiquidityInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FillLiquidityInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FillLiquidityInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FillLiquidityInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillLiquidityInd";
  FIX::FillLiquidityInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::FillLiquidityInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::FillLiquidityInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::FillLiquidityInd *)new FIX::FillLiquidityInd((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FillLiquidityInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FillLiquidityInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillLiquidityInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FillLiquidityInd.new", 
    "    FillLiquidityInd.new()\n"
    "    FillLiquidityInd.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FillLiquidityInd(FIX::FillLiquidityInd *arg1) {
    delete arg1;
}

swig_class SwigClassMassActionReportID;

SWIGINTERN VALUE
_wrap_new_MassActionReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassActionReportID";
  FIX::MassActionReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassActionReportID *)new FIX::MassActionReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassActionReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassActionReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassActionReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassActionReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionReportID";
  FIX::MassActionReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MassActionReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MassActionReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MassActionReportID *)new FIX::MassActionReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassActionReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassActionReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassActionReportID.new", 
    "    MassActionReportID.new()\n"
    "    MassActionReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionReportID(FIX::MassActionReportID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeIssuer;

SWIGINTERN VALUE
_wrap_new_DerivativeIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssuer";
  FIX::DerivativeIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeIssuer *)new FIX::DerivativeIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssuer";
  FIX::DerivativeIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeIssuer *)new FIX::DerivativeIssuer((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeIssuer.new", 
    "    DerivativeIssuer.new()\n"
    "    DerivativeIssuer.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeIssuer(FIX::DerivativeIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassExDestinationIDSource;

SWIGINTERN VALUE
_wrap_new_ExDestinationIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExDestinationIDSource";
  FIX::ExDestinationIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExDestinationIDSource *)new FIX::ExDestinationIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExDestinationIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExDestinationIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExDestinationIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExDestinationIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDestinationIDSource";
  FIX::ExDestinationIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExDestinationIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExDestinationIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExDestinationIDSource *)new FIX::ExDestinationIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExDestinationIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExDestinationIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExDestinationIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExDestinationIDSource.new", 
    "    ExDestinationIDSource.new()\n"
    "    ExDestinationIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExDestinationIDSource(FIX::ExDestinationIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassCollRespID;

SWIGINTERN VALUE
_wrap_new_CollRespID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollRespID";
  FIX::CollRespID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollRespID *)new FIX::CollRespID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollRespID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollRespID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollRespID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollRespID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollRespID";
  FIX::CollRespID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CollRespID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CollRespID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CollRespID *)new FIX::CollRespID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollRespID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollRespID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollRespID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollRespID.new", 
    "    CollRespID.new()\n"
    "    CollRespID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollRespID(FIX::CollRespID *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityListRequestType;

SWIGINTERN VALUE
_wrap_new_SecurityListRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRequestType";
  FIX::SecurityListRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityListRequestType *)new FIX::SecurityListRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityListRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityListRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityListRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityListRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRequestType";
  FIX::SecurityListRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityListRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityListRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityListRequestType *)new FIX::SecurityListRequestType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityListRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityListRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityListRequestType.new", 
    "    SecurityListRequestType.new()\n"
    "    SecurityListRequestType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListRequestType(FIX::SecurityListRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedLegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_EncodedLegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDesc";
  FIX::EncodedLegSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedLegSecurityDesc *)new FIX::EncodedLegSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedLegSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedLegSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedLegSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedLegSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDesc";
  FIX::EncodedLegSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedLegSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedLegSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedLegSecurityDesc *)new FIX::EncodedLegSecurityDesc((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedLegSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedLegSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedLegSecurityDesc.new", 
    "    EncodedLegSecurityDesc.new()\n"
    "    EncodedLegSecurityDesc.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegSecurityDesc(FIX::EncodedLegSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSettlementStatus;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementStatus";
  FIX::UnderlyingSettlementStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSettlementStatus *)new FIX::UnderlyingSettlementStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSettlementStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSettlementStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSettlementStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementStatus";
  FIX::UnderlyingSettlementStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSettlementStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSettlementStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSettlementStatus *)new FIX::UnderlyingSettlementStatus((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSettlementStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSettlementStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlementStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSettlementStatus.new", 
    "    UnderlyingSettlementStatus.new()\n"
    "    UnderlyingSettlementStatus.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlementStatus(FIX::UnderlyingSettlementStatus *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityAltID;

SWIGINTERN VALUE
_wrap_new_SecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltID";
  FIX::SecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityAltID *)new FIX::SecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltID";
  FIX::SecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityAltID *)new FIX::SecurityAltID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityAltID.new", 
    "    SecurityAltID.new()\n"
    "    SecurityAltID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityAltID(FIX::SecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassRegistRefID;

SWIGINTERN VALUE
_wrap_new_RegistRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistRefID";
  FIX::RegistRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistRefID *)new FIX::RegistRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRefID";
  FIX::RegistRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistRefID *)new FIX::RegistRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistRefID.new", 
    "    RegistRefID.new()\n"
    "    RegistRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistRefID(FIX::RegistRefID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativePriceQuoteMethod;

SWIGINTERN VALUE
_wrap_new_DerivativePriceQuoteMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceQuoteMethod";
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativePriceQuoteMethod *)new FIX::DerivativePriceQuoteMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativePriceQuoteMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativePriceQuoteMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativePriceQuoteMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativePriceQuoteMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceQuoteMethod";
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativePriceQuoteMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativePriceQuoteMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativePriceQuoteMethod *)new FIX::DerivativePriceQuoteMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativePriceQuoteMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativePriceQuoteMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePriceQuoteMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativePriceQuoteMethod.new", 
    "    DerivativePriceQuoteMethod.new()\n"
    "    DerivativePriceQuoteMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePriceQuoteMethod(FIX::DerivativePriceQuoteMethod *arg1) {
    delete arg1;
}

swig_class SwigClassOrderDelay;

SWIGINTERN VALUE
_wrap_new_OrderDelay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderDelay";
  FIX::OrderDelay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderDelay *)new FIX::OrderDelay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderDelay_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderDelay_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderDelay);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderDelay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderDelay";
  FIX::OrderDelay *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OrderDelay", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OrderDelay", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OrderDelay *)new FIX::OrderDelay((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderDelay(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderDelay__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderDelay__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderDelay.new", 
    "    OrderDelay.new()\n"
    "    OrderDelay.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderDelay(FIX::OrderDelay *arg1) {
    delete arg1;
}

swig_class SwigClassNoNotAffectedOrders;

SWIGINTERN VALUE
_wrap_new_NoNotAffectedOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNotAffectedOrders";
  FIX::NoNotAffectedOrders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNotAffectedOrders *)new FIX::NoNotAffectedOrders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNotAffectedOrders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNotAffectedOrders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNotAffectedOrders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNotAffectedOrders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNotAffectedOrders";
  FIX::NoNotAffectedOrders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNotAffectedOrders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNotAffectedOrders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNotAffectedOrders *)new FIX::NoNotAffectedOrders((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNotAffectedOrders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNotAffectedOrders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNotAffectedOrders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNotAffectedOrders.new", 
    "    NoNotAffectedOrders.new()\n"
    "    NoNotAffectedOrders.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNotAffectedOrders(FIX::NoNotAffectedOrders *arg1) {
    delete arg1;
}

swig_class SwigClassNested3PartyID;

SWIGINTERN VALUE
_wrap_new_Nested3PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyID";
  FIX::Nested3PartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested3PartyID *)new FIX::Nested3PartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested3PartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested3PartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested3PartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested3PartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyID";
  FIX::Nested3PartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Nested3PartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Nested3PartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Nested3PartyID *)new FIX::Nested3PartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested3PartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested3PartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested3PartyID.new", 
    "    Nested3PartyID.new()\n"
    "    Nested3PartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartyID(FIX::Nested3PartyID *arg1) {
    delete arg1;
}

swig_class SwigClassCollAsgnReason;

SWIGINTERN VALUE
_wrap_new_CollAsgnReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnReason";
  FIX::CollAsgnReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAsgnReason *)new FIX::CollAsgnReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAsgnReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAsgnReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAsgnReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAsgnReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnReason";
  FIX::CollAsgnReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollAsgnReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollAsgnReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollAsgnReason *)new FIX::CollAsgnReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAsgnReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAsgnReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAsgnReason.new", 
    "    CollAsgnReason.new()\n"
    "    CollAsgnReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnReason(FIX::CollAsgnReason *arg1) {
    delete arg1;
}

swig_class SwigClassTotalVolumeTradedTime;

SWIGINTERN VALUE
_wrap_new_TotalVolumeTradedTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedTime";
  FIX::TotalVolumeTradedTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalVolumeTradedTime *)new FIX::TotalVolumeTradedTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalVolumeTradedTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalVolumeTradedTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalVolumeTradedTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalVolumeTradedTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedTime";
  FIX::TotalVolumeTradedTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMEONLY const &","FIX::TotalVolumeTradedTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMEONLY const &","FIX::TotalVolumeTradedTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  result = (FIX::TotalVolumeTradedTime *)new FIX::TotalVolumeTradedTime((FIX::UTCTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalVolumeTradedTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalVolumeTradedTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTradedTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalVolumeTradedTime.new", 
    "    TotalVolumeTradedTime.new()\n"
    "    TotalVolumeTradedTime.new(FIX::UTCTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalVolumeTradedTime(FIX::TotalVolumeTradedTime *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityExchange;

SWIGINTERN VALUE
_wrap_new_SecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityExchange";
  FIX::SecurityExchange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityExchange *)new FIX::SecurityExchange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityExchange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityExchange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityExchange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityExchange";
  FIX::SecurityExchange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::SecurityExchange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::SecurityExchange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::SecurityExchange *)new FIX::SecurityExchange((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityExchange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityExchange.new", 
    "    SecurityExchange.new()\n"
    "    SecurityExchange.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityExchange(FIX::SecurityExchange *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPriceType;

SWIGINTERN VALUE
_wrap_new_SettlPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPriceType";
  FIX::SettlPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPriceType *)new FIX::SettlPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPriceType";
  FIX::SettlPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlPriceType *)new FIX::SettlPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPriceType.new", 
    "    SettlPriceType.new()\n"
    "    SettlPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPriceType(FIX::SettlPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_UnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasureQty";
  FIX::UnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnitOfMeasureQty *)new FIX::UnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasureQty";
  FIX::UnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::UnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::UnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::UnitOfMeasureQty *)new FIX::UnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnitOfMeasureQty.new", 
    "    UnitOfMeasureQty.new()\n"
    "    UnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnitOfMeasureQty(FIX::UnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassUserRequestID;

SWIGINTERN VALUE
_wrap_new_UserRequestID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UserRequestID";
  FIX::UserRequestID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UserRequestID *)new FIX::UserRequestID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UserRequestID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UserRequestID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UserRequestID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UserRequestID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserRequestID";
  FIX::UserRequestID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UserRequestID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UserRequestID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UserRequestID *)new FIX::UserRequestID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UserRequestID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UserRequestID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserRequestID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UserRequestID.new", 
    "    UserRequestID.new()\n"
    "    UserRequestID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UserRequestID(FIX::UserRequestID *arg1) {
    delete arg1;
}

swig_class SwigClassLastParPx;

SWIGINTERN VALUE
_wrap_new_LastParPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastParPx";
  FIX::LastParPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastParPx *)new FIX::LastParPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastParPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastParPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastParPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastParPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastParPx";
  FIX::LastParPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LastParPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LastParPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LastParPx *)new FIX::LastParPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastParPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastParPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastParPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastParPx.new", 
    "    LastParPx.new()\n"
    "    LastParPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastParPx(FIX::LastParPx *arg1) {
    delete arg1;
}

swig_class SwigClassEndMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_EndMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndMaturityMonthYear";
  FIX::EndMaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndMaturityMonthYear *)new FIX::EndMaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndMaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndMaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndMaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndMaturityMonthYear";
  FIX::EndMaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::EndMaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::EndMaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::EndMaturityMonthYear *)new FIX::EndMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndMaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndMaturityMonthYear.new", 
    "    EndMaturityMonthYear.new()\n"
    "    EndMaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndMaturityMonthYear(FIX::EndMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassDealingCapacity;

SWIGINTERN VALUE
_wrap_new_DealingCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DealingCapacity";
  FIX::DealingCapacity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DealingCapacity *)new FIX::DealingCapacity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DealingCapacity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DealingCapacity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DealingCapacity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DealingCapacity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DealingCapacity";
  FIX::DealingCapacity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DealingCapacity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DealingCapacity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DealingCapacity *)new FIX::DealingCapacity((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DealingCapacity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DealingCapacity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DealingCapacity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DealingCapacity.new", 
    "    DealingCapacity.new()\n"
    "    DealingCapacity.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DealingCapacity(FIX::DealingCapacity *arg1) {
    delete arg1;
}

swig_class SwigClassPrevClosePx;

SWIGINTERN VALUE
_wrap_new_PrevClosePx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PrevClosePx";
  FIX::PrevClosePx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PrevClosePx *)new FIX::PrevClosePx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PrevClosePx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PrevClosePx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PrevClosePx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PrevClosePx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PrevClosePx";
  FIX::PrevClosePx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::PrevClosePx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::PrevClosePx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::PrevClosePx *)new FIX::PrevClosePx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PrevClosePx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PrevClosePx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PrevClosePx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PrevClosePx.new", 
    "    PrevClosePx.new()\n"
    "    PrevClosePx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PrevClosePx(FIX::PrevClosePx *arg1) {
    delete arg1;
}

swig_class SwigClassTradeInputDevice;

SWIGINTERN VALUE
_wrap_new_TradeInputDevice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeInputDevice";
  FIX::TradeInputDevice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeInputDevice *)new FIX::TradeInputDevice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeInputDevice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeInputDevice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeInputDevice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeInputDevice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeInputDevice";
  FIX::TradeInputDevice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeInputDevice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeInputDevice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeInputDevice *)new FIX::TradeInputDevice((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeInputDevice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeInputDevice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeInputDevice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeInputDevice.new", 
    "    TradeInputDevice.new()\n"
    "    TradeInputDevice.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeInputDevice(FIX::TradeInputDevice *arg1) {
    delete arg1;
}

swig_class SwigClassDayCumQty;

SWIGINTERN VALUE
_wrap_new_DayCumQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DayCumQty";
  FIX::DayCumQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DayCumQty *)new FIX::DayCumQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DayCumQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DayCumQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DayCumQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DayCumQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayCumQty";
  FIX::DayCumQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DayCumQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DayCumQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DayCumQty *)new FIX::DayCumQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DayCumQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DayCumQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayCumQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DayCumQty.new", 
    "    DayCumQty.new()\n"
    "    DayCumQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DayCumQty(FIX::DayCumQty *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySettlAgentAcctNum;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentAcctNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctNum";
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySettlAgentAcctNum *)new FIX::SecuritySettlAgentAcctNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySettlAgentAcctNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySettlAgentAcctNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentAcctNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctNum";
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySettlAgentAcctNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySettlAgentAcctNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySettlAgentAcctNum *)new FIX::SecuritySettlAgentAcctNum((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySettlAgentAcctNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySettlAgentAcctNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentAcctNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySettlAgentAcctNum.new", 
    "    SecuritySettlAgentAcctNum.new()\n"
    "    SecuritySettlAgentAcctNum.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentAcctNum(FIX::SecuritySettlAgentAcctNum *arg1) {
    delete arg1;
}

swig_class SwigClassLegCurrency;

SWIGINTERN VALUE
_wrap_new_LegCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCurrency";
  FIX::LegCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCurrency *)new FIX::LegCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCurrency";
  FIX::LegCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::LegCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::LegCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::LegCurrency *)new FIX::LegCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCurrency.new", 
    "    LegCurrency.new()\n"
    "    LegCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCurrency(FIX::LegCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassEncryptedNewPassword;

SWIGINTERN VALUE
_wrap_new_EncryptedNewPassword__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPassword";
  FIX::EncryptedNewPassword *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncryptedNewPassword *)new FIX::EncryptedNewPassword();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncryptedNewPassword_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncryptedNewPassword_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncryptedNewPassword);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncryptedNewPassword__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPassword";
  FIX::EncryptedNewPassword *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncryptedNewPassword", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncryptedNewPassword", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncryptedNewPassword *)new FIX::EncryptedNewPassword((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncryptedNewPassword(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncryptedNewPassword__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedNewPassword__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncryptedNewPassword.new", 
    "    EncryptedNewPassword.new()\n"
    "    EncryptedNewPassword.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedNewPassword(FIX::EncryptedNewPassword *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeMinPriceIncrementAmount;

SWIGINTERN VALUE
_wrap_new_DerivativeMinPriceIncrementAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrementAmount";
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeMinPriceIncrementAmount *)new FIX::DerivativeMinPriceIncrementAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeMinPriceIncrementAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeMinPriceIncrementAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeMinPriceIncrementAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrementAmount";
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::DerivativeMinPriceIncrementAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::DerivativeMinPriceIncrementAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::DerivativeMinPriceIncrementAmount *)new FIX::DerivativeMinPriceIncrementAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeMinPriceIncrementAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeMinPriceIncrementAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMinPriceIncrementAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeMinPriceIncrementAmount.new", 
    "    DerivativeMinPriceIncrementAmount.new()\n"
    "    DerivativeMinPriceIncrementAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMinPriceIncrementAmount(FIX::DerivativeMinPriceIncrementAmount *arg1) {
    delete arg1;
}

swig_class SwigClassNoNested3PartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNested3PartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartySubIDs";
  FIX::NoNested3PartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNested3PartySubIDs *)new FIX::NoNested3PartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNested3PartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNested3PartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNested3PartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNested3PartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartySubIDs";
  FIX::NoNested3PartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNested3PartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNested3PartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNested3PartySubIDs *)new FIX::NoNested3PartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNested3PartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNested3PartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested3PartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNested3PartySubIDs.new", 
    "    NoNested3PartySubIDs.new()\n"
    "    NoNested3PartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested3PartySubIDs(FIX::NoNested3PartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassRefSubID;

SWIGINTERN VALUE
_wrap_new_RefSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefSubID";
  FIX::RefSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefSubID *)new FIX::RefSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefSubID";
  FIX::RefSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefSubID *)new FIX::RefSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefSubID.new", 
    "    RefSubID.new()\n"
    "    RefSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefSubID(FIX::RefSubID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPartyRole;

SWIGINTERN VALUE
_wrap_new_SettlPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyRole";
  FIX::SettlPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPartyRole *)new FIX::SettlPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyRole";
  FIX::SettlPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlPartyRole *)new FIX::SettlPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPartyRole.new", 
    "    SettlPartyRole.new()\n"
    "    SettlPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartyRole(FIX::SettlPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassCashDistribAgentName;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentName";
  FIX::CashDistribAgentName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashDistribAgentName *)new FIX::CashDistribAgentName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashDistribAgentName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashDistribAgentName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashDistribAgentName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashDistribAgentName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentName";
  FIX::CashDistribAgentName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashDistribAgentName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashDistribAgentName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashDistribAgentName *)new FIX::CashDistribAgentName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashDistribAgentName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashDistribAgentName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashDistribAgentName.new", 
    "    CashDistribAgentName.new()\n"
    "    CashDistribAgentName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentName(FIX::CashDistribAgentName *arg1) {
    delete arg1;
}

swig_class SwigClassLegContractMultiplier;

SWIGINTERN VALUE
_wrap_new_LegContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplier";
  FIX::LegContractMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegContractMultiplier *)new FIX::LegContractMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegContractMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegContractMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegContractMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegContractMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplier";
  FIX::LegContractMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::LegContractMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::LegContractMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::LegContractMultiplier *)new FIX::LegContractMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegContractMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegContractMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegContractMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegContractMultiplier.new", 
    "    LegContractMultiplier.new()\n"
    "    LegContractMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegContractMultiplier(FIX::LegContractMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassProgPeriodInterval;

SWIGINTERN VALUE
_wrap_new_ProgPeriodInterval__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ProgPeriodInterval";
  FIX::ProgPeriodInterval *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ProgPeriodInterval *)new FIX::ProgPeriodInterval();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ProgPeriodInterval_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ProgPeriodInterval_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ProgPeriodInterval);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ProgPeriodInterval__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProgPeriodInterval";
  FIX::ProgPeriodInterval *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ProgPeriodInterval", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ProgPeriodInterval", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ProgPeriodInterval *)new FIX::ProgPeriodInterval((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ProgPeriodInterval(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ProgPeriodInterval__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProgPeriodInterval__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ProgPeriodInterval.new", 
    "    ProgPeriodInterval.new()\n"
    "    ProgPeriodInterval.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ProgPeriodInterval(FIX::ProgPeriodInterval *arg1) {
    delete arg1;
}

swig_class SwigClassLegSettlType;

SWIGINTERN VALUE
_wrap_new_LegSettlType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSettlType";
  FIX::LegSettlType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSettlType *)new FIX::LegSettlType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSettlType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSettlType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSettlType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSettlType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlType";
  FIX::LegSettlType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LegSettlType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LegSettlType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LegSettlType *)new FIX::LegSettlType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSettlType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSettlType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSettlType.new", 
    "    LegSettlType.new()\n"
    "    LegSettlType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlType(FIX::LegSettlType *arg1) {
    delete arg1;
}

swig_class SwigClassOnBehalfOfLocationID;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfLocationID";
  FIX::OnBehalfOfLocationID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OnBehalfOfLocationID *)new FIX::OnBehalfOfLocationID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OnBehalfOfLocationID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OnBehalfOfLocationID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OnBehalfOfLocationID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OnBehalfOfLocationID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfLocationID";
  FIX::OnBehalfOfLocationID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OnBehalfOfLocationID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OnBehalfOfLocationID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OnBehalfOfLocationID *)new FIX::OnBehalfOfLocationID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OnBehalfOfLocationID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OnBehalfOfLocationID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfLocationID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OnBehalfOfLocationID.new", 
    "    OnBehalfOfLocationID.new()\n"
    "    OnBehalfOfLocationID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfLocationID(FIX::OnBehalfOfLocationID *arg1) {
    delete arg1;
}

swig_class SwigClassOnBehalfOfSubID;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSubID";
  FIX::OnBehalfOfSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OnBehalfOfSubID *)new FIX::OnBehalfOfSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OnBehalfOfSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OnBehalfOfSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OnBehalfOfSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OnBehalfOfSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSubID";
  FIX::OnBehalfOfSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OnBehalfOfSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OnBehalfOfSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OnBehalfOfSubID *)new FIX::OnBehalfOfSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OnBehalfOfSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OnBehalfOfSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OnBehalfOfSubID.new", 
    "    OnBehalfOfSubID.new()\n"
    "    OnBehalfOfSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfSubID(FIX::OnBehalfOfSubID *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventEndTime;

SWIGINTERN VALUE
_wrap_new_ComplexEventEndTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndTime";
  FIX::ComplexEventEndTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventEndTime *)new FIX::ComplexEventEndTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventEndTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventEndTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventEndTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventEndTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndTime";
  FIX::ComplexEventEndTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMEONLY const &","FIX::ComplexEventEndTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMEONLY const &","FIX::ComplexEventEndTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  result = (FIX::ComplexEventEndTime *)new FIX::ComplexEventEndTime((FIX::UTCTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventEndTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventEndTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventEndTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventEndTime.new", 
    "    ComplexEventEndTime.new()\n"
    "    ComplexEventEndTime.new(FIX::UTCTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventEndTime(FIX::ComplexEventEndTime *arg1) {
    delete arg1;
}

swig_class SwigClassRateSourceType;

SWIGINTERN VALUE
_wrap_new_RateSourceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RateSourceType";
  FIX::RateSourceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RateSourceType *)new FIX::RateSourceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RateSourceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RateSourceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RateSourceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RateSourceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RateSourceType";
  FIX::RateSourceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RateSourceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RateSourceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RateSourceType *)new FIX::RateSourceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RateSourceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RateSourceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RateSourceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RateSourceType.new", 
    "    RateSourceType.new()\n"
    "    RateSourceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RateSourceType(FIX::RateSourceType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStateOrProvinceOfIssue";
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeStateOrProvinceOfIssue *)new FIX::DerivativeStateOrProvinceOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeStateOrProvinceOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeStateOrProvinceOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStateOrProvinceOfIssue";
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeStateOrProvinceOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeStateOrProvinceOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeStateOrProvinceOfIssue *)new FIX::DerivativeStateOrProvinceOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeStateOrProvinceOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeStateOrProvinceOfIssue.new", 
    "    DerivativeStateOrProvinceOfIssue.new()\n"
    "    DerivativeStateOrProvinceOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStateOrProvinceOfIssue(FIX::DerivativeStateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassTradeLegRefID;

SWIGINTERN VALUE
_wrap_new_TradeLegRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeLegRefID";
  FIX::TradeLegRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeLegRefID *)new FIX::TradeLegRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeLegRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeLegRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeLegRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeLegRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeLegRefID";
  FIX::TradeLegRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeLegRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeLegRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeLegRefID *)new FIX::TradeLegRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeLegRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeLegRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeLegRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeLegRefID.new", 
    "    TradeLegRefID.new()\n"
    "    TradeLegRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeLegRefID(FIX::TradeLegRefID *arg1) {
    delete arg1;
}

swig_class SwigClassRelSymTransactTime;

SWIGINTERN VALUE
_wrap_new_RelSymTransactTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  FIX::RelSymTransactTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RelSymTransactTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  FIX::RelSymTransactTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::RelSymTransactTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RelSymTransactTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  FIX::RelSymTransactTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::RelSymTransactTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::RelSymTransactTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RelSymTransactTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RelSymTransactTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RelSymTransactTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RelSymTransactTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  FIX::RelSymTransactTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::RelSymTransactTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::RelSymTransactTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::RelSymTransactTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelSymTransactTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelSymTransactTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelSymTransactTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RelSymTransactTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RelSymTransactTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RelSymTransactTime.new", 
    "    RelSymTransactTime.new()\n"
    "    RelSymTransactTime.new(bool showMilliseconds)\n"
    "    RelSymTransactTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    RelSymTransactTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RelSymTransactTime(FIX::RelSymTransactTime *arg1) {
    delete arg1;
}

swig_class SwigClassNoComplexEventTimes;

SWIGINTERN VALUE
_wrap_new_NoComplexEventTimes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventTimes";
  FIX::NoComplexEventTimes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoComplexEventTimes *)new FIX::NoComplexEventTimes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoComplexEventTimes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoComplexEventTimes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoComplexEventTimes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoComplexEventTimes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventTimes";
  FIX::NoComplexEventTimes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoComplexEventTimes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoComplexEventTimes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoComplexEventTimes *)new FIX::NoComplexEventTimes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoComplexEventTimes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoComplexEventTimes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoComplexEventTimes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoComplexEventTimes.new", 
    "    NoComplexEventTimes.new()\n"
    "    NoComplexEventTimes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoComplexEventTimes(FIX::NoComplexEventTimes *arg1) {
    delete arg1;
}

swig_class SwigClassLegCalculatedCcyLastQty;

SWIGINTERN VALUE
_wrap_new_LegCalculatedCcyLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCalculatedCcyLastQty";
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCalculatedCcyLastQty *)new FIX::LegCalculatedCcyLastQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCalculatedCcyLastQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCalculatedCcyLastQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCalculatedCcyLastQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCalculatedCcyLastQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCalculatedCcyLastQty";
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegCalculatedCcyLastQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegCalculatedCcyLastQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegCalculatedCcyLastQty *)new FIX::LegCalculatedCcyLastQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCalculatedCcyLastQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCalculatedCcyLastQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCalculatedCcyLastQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCalculatedCcyLastQty.new", 
    "    LegCalculatedCcyLastQty.new()\n"
    "    LegCalculatedCcyLastQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCalculatedCcyLastQty(FIX::LegCalculatedCcyLastQty *arg1) {
    delete arg1;
}

swig_class SwigClassNested3PartyIDSource;

SWIGINTERN VALUE
_wrap_new_Nested3PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyIDSource";
  FIX::Nested3PartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested3PartyIDSource *)new FIX::Nested3PartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested3PartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested3PartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested3PartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested3PartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyIDSource";
  FIX::Nested3PartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Nested3PartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Nested3PartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Nested3PartyIDSource *)new FIX::Nested3PartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested3PartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested3PartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested3PartyIDSource.new", 
    "    Nested3PartyIDSource.new()\n"
    "    Nested3PartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartyIDSource(FIX::Nested3PartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassDatedDate;

SWIGINTERN VALUE
_wrap_new_DatedDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DatedDate";
  FIX::DatedDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DatedDate *)new FIX::DatedDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DatedDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DatedDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DatedDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DatedDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DatedDate";
  FIX::DatedDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::DatedDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::DatedDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::DatedDate *)new FIX::DatedDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DatedDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DatedDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DatedDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DatedDate.new", 
    "    DatedDate.new()\n"
    "    DatedDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DatedDate(FIX::DatedDate *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstID;

SWIGINTERN VALUE
_wrap_new_SettlInstID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstID";
  FIX::SettlInstID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstID *)new FIX::SettlInstID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstID";
  FIX::SettlInstID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlInstID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlInstID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlInstID *)new FIX::SettlInstID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstID.new", 
    "    SettlInstID.new()\n"
    "    SettlInstID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstID(FIX::SettlInstID *arg1) {
    delete arg1;
}

swig_class SwigClassOpenInterest;

SWIGINTERN VALUE
_wrap_new_OpenInterest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OpenInterest";
  FIX::OpenInterest *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OpenInterest *)new FIX::OpenInterest();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OpenInterest_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OpenInterest_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OpenInterest);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OpenInterest__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenInterest";
  FIX::OpenInterest *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::OpenInterest", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::OpenInterest", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::OpenInterest *)new FIX::OpenInterest((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OpenInterest(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OpenInterest__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenInterest__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OpenInterest.new", 
    "    OpenInterest.new()\n"
    "    OpenInterest.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenInterest(FIX::OpenInterest *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingContractMultiplier;

SWIGINTERN VALUE
_wrap_new_UnderlyingContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplier";
  FIX::UnderlyingContractMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingContractMultiplier *)new FIX::UnderlyingContractMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingContractMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingContractMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingContractMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingContractMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplier";
  FIX::UnderlyingContractMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::UnderlyingContractMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::UnderlyingContractMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::UnderlyingContractMultiplier *)new FIX::UnderlyingContractMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingContractMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingContractMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingContractMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingContractMultiplier.new", 
    "    UnderlyingContractMultiplier.new()\n"
    "    UnderlyingContractMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingContractMultiplier(FIX::UnderlyingContractMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassTotQuoteEntries;

SWIGINTERN VALUE
_wrap_new_TotQuoteEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotQuoteEntries";
  FIX::TotQuoteEntries *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotQuoteEntries *)new FIX::TotQuoteEntries();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotQuoteEntries_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotQuoteEntries_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotQuoteEntries);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotQuoteEntries__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotQuoteEntries";
  FIX::TotQuoteEntries *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotQuoteEntries", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotQuoteEntries", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotQuoteEntries *)new FIX::TotQuoteEntries((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotQuoteEntries(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotQuoteEntries__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotQuoteEntries__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotQuoteEntries.new", 
    "    TotQuoteEntries.new()\n"
    "    TotQuoteEntries.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotQuoteEntries(FIX::TotQuoteEntries *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoCxldQuotes;

SWIGINTERN VALUE
_wrap_new_TotNoCxldQuotes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoCxldQuotes";
  FIX::TotNoCxldQuotes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoCxldQuotes *)new FIX::TotNoCxldQuotes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoCxldQuotes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoCxldQuotes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoCxldQuotes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoCxldQuotes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoCxldQuotes";
  FIX::TotNoCxldQuotes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoCxldQuotes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoCxldQuotes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoCxldQuotes *)new FIX::TotNoCxldQuotes((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoCxldQuotes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoCxldQuotes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoCxldQuotes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoCxldQuotes.new", 
    "    TotNoCxldQuotes.new()\n"
    "    TotNoCxldQuotes.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoCxldQuotes(FIX::TotNoCxldQuotes *arg1) {
    delete arg1;
}

swig_class SwigClassAggregatedBook;

SWIGINTERN VALUE
_wrap_new_AggregatedBook__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AggregatedBook";
  FIX::AggregatedBook *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AggregatedBook *)new FIX::AggregatedBook();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AggregatedBook_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AggregatedBook_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AggregatedBook);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AggregatedBook__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AggregatedBook";
  FIX::AggregatedBook *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::AggregatedBook", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::AggregatedBook", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::AggregatedBook *)new FIX::AggregatedBook((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AggregatedBook(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AggregatedBook__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AggregatedBook__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AggregatedBook.new", 
    "    AggregatedBook.new()\n"
    "    AggregatedBook.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AggregatedBook(FIX::AggregatedBook *arg1) {
    delete arg1;
}

swig_class SwigClassPaymentRef;

SWIGINTERN VALUE
_wrap_new_PaymentRef__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PaymentRef";
  FIX::PaymentRef *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PaymentRef *)new FIX::PaymentRef();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PaymentRef_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PaymentRef_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PaymentRef);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PaymentRef__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentRef";
  FIX::PaymentRef *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PaymentRef", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PaymentRef", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PaymentRef *)new FIX::PaymentRef((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PaymentRef(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PaymentRef__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentRef__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PaymentRef.new", 
    "    PaymentRef.new()\n"
    "    PaymentRef.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentRef(FIX::PaymentRef *arg1) {
    delete arg1;
}

swig_class SwigClassPaymentDate;

SWIGINTERN VALUE
_wrap_new_PaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PaymentDate";
  FIX::PaymentDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PaymentDate *)new FIX::PaymentDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PaymentDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PaymentDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PaymentDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PaymentDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentDate";
  FIX::PaymentDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::PaymentDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::PaymentDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::PaymentDate *)new FIX::PaymentDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PaymentDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PaymentDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PaymentDate.new", 
    "    PaymentDate.new()\n"
    "    PaymentDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentDate(FIX::PaymentDate *arg1) {
    delete arg1;
}

swig_class SwigClassOrderPercent;

SWIGINTERN VALUE
_wrap_new_OrderPercent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderPercent";
  FIX::OrderPercent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderPercent *)new FIX::OrderPercent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderPercent_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderPercent_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderPercent);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderPercent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderPercent";
  FIX::OrderPercent *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::OrderPercent", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::OrderPercent", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::OrderPercent *)new FIX::OrderPercent((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderPercent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderPercent__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderPercent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderPercent.new", 
    "    OrderPercent.new()\n"
    "    OrderPercent.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderPercent(FIX::OrderPercent *arg1) {
    delete arg1;
}

swig_class SwigClassPosQtyStatus;

SWIGINTERN VALUE
_wrap_new_PosQtyStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosQtyStatus";
  FIX::PosQtyStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosQtyStatus *)new FIX::PosQtyStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosQtyStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosQtyStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosQtyStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosQtyStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosQtyStatus";
  FIX::PosQtyStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosQtyStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosQtyStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosQtyStatus *)new FIX::PosQtyStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosQtyStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosQtyStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosQtyStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosQtyStatus.new", 
    "    PosQtyStatus.new()\n"
    "    PosQtyStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosQtyStatus(FIX::PosQtyStatus *arg1) {
    delete arg1;
}

swig_class SwigClassNoNested4PartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNested4PartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartySubIDs";
  FIX::NoNested4PartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNested4PartySubIDs *)new FIX::NoNested4PartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNested4PartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNested4PartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNested4PartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNested4PartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartySubIDs";
  FIX::NoNested4PartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNested4PartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNested4PartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNested4PartySubIDs *)new FIX::NoNested4PartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNested4PartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNested4PartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested4PartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNested4PartySubIDs.new", 
    "    NoNested4PartySubIDs.new()\n"
    "    NoNested4PartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested4PartySubIDs(FIX::NoNested4PartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassPrivateQuote;

SWIGINTERN VALUE
_wrap_new_PrivateQuote__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PrivateQuote";
  FIX::PrivateQuote *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PrivateQuote *)new FIX::PrivateQuote();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PrivateQuote_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PrivateQuote_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PrivateQuote);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PrivateQuote__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PrivateQuote";
  FIX::PrivateQuote *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PrivateQuote", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PrivateQuote", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PrivateQuote *)new FIX::PrivateQuote((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PrivateQuote(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PrivateQuote__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PrivateQuote__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PrivateQuote.new", 
    "    PrivateQuote.new()\n"
    "    PrivateQuote.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PrivateQuote(FIX::PrivateQuote *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryTradeID;

SWIGINTERN VALUE
_wrap_new_SecondaryTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeID";
  FIX::SecondaryTradeID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryTradeID *)new FIX::SecondaryTradeID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryTradeID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryTradeID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryTradeID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryTradeID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeID";
  FIX::SecondaryTradeID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryTradeID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryTradeID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryTradeID *)new FIX::SecondaryTradeID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryTradeID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryTradeID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradeID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryTradeID.new", 
    "    SecondaryTradeID.new()\n"
    "    SecondaryTradeID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradeID(FIX::SecondaryTradeID *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySettlAgentContactPhone;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentContactPhone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactPhone";
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySettlAgentContactPhone *)new FIX::SecuritySettlAgentContactPhone();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySettlAgentContactPhone_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySettlAgentContactPhone_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentContactPhone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactPhone";
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySettlAgentContactPhone", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySettlAgentContactPhone", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySettlAgentContactPhone *)new FIX::SecuritySettlAgentContactPhone((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySettlAgentContactPhone(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySettlAgentContactPhone__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentContactPhone__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySettlAgentContactPhone.new", 
    "    SecuritySettlAgentContactPhone.new()\n"
    "    SecuritySettlAgentContactPhone.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentContactPhone(FIX::SecuritySettlAgentContactPhone *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedMktSegmDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedMktSegmDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDescLen";
  FIX::EncodedMktSegmDescLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedMktSegmDescLen *)new FIX::EncodedMktSegmDescLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedMktSegmDescLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedMktSegmDescLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedMktSegmDescLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedMktSegmDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDescLen";
  FIX::EncodedMktSegmDescLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedMktSegmDescLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedMktSegmDescLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedMktSegmDescLen *)new FIX::EncodedMktSegmDescLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedMktSegmDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedMktSegmDescLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedMktSegmDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedMktSegmDescLen.new", 
    "    EncodedMktSegmDescLen.new()\n"
    "    EncodedMktSegmDescLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedMktSegmDescLen(FIX::EncodedMktSegmDescLen *arg1) {
    delete arg1;
}

swig_class SwigClassSideCurrency;

SWIGINTERN VALUE
_wrap_new_SideCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideCurrency";
  FIX::SideCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideCurrency *)new FIX::SideCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideCurrency";
  FIX::SideCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::SideCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::SideCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::SideCurrency *)new FIX::SideCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideCurrency.new", 
    "    SideCurrency.new()\n"
    "    SideCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideCurrency(FIX::SideCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassLegQty;

SWIGINTERN VALUE
_wrap_new_LegQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegQty";
  FIX::LegQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegQty *)new FIX::LegQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegQty";
  FIX::LegQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegQty *)new FIX::LegQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegQty.new", 
    "    LegQty.new()\n"
    "    LegQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegQty(FIX::LegQty *arg1) {
    delete arg1;
}

swig_class SwigClassMsgType;

SWIGINTERN VALUE
_wrap_new_MsgType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MsgType";
  FIX::MsgType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MsgType *)new FIX::MsgType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MsgType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MsgType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MsgType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MsgType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgType";
  FIX::MsgType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MsgType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MsgType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MsgType *)new FIX::MsgType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MsgType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MsgType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MsgType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MsgType.new", 
    "    MsgType.new()\n"
    "    MsgType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MsgType(FIX::MsgType *arg1) {
    delete arg1;
}

swig_class SwigClassNoTradingSessions;

SWIGINTERN VALUE
_wrap_new_NoTradingSessions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessions";
  FIX::NoTradingSessions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTradingSessions *)new FIX::NoTradingSessions();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTradingSessions_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTradingSessions_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTradingSessions);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTradingSessions__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessions";
  FIX::NoTradingSessions *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTradingSessions", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTradingSessions", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTradingSessions *)new FIX::NoTradingSessions((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTradingSessions(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTradingSessions__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTradingSessions__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTradingSessions.new", 
    "    NoTradingSessions.new()\n"
    "    NoTradingSessions.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTradingSessions(FIX::NoTradingSessions *arg1) {
    delete arg1;
}

swig_class SwigClassIOIid;

SWIGINTERN VALUE
_wrap_new_IOIid__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIid";
  FIX::IOIid *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIid *)new FIX::IOIid();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIid_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIid_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIid);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIid__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIid";
  FIX::IOIid *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IOIid", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IOIid", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IOIid *)new FIX::IOIid((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIid(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIid__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIid__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIid.new", 
    "    IOIid.new()\n"
    "    IOIid.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIid(FIX::IOIid *arg1) {
    delete arg1;
}

swig_class SwigClassMultiLegReportingType;

SWIGINTERN VALUE
_wrap_new_MultiLegReportingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MultiLegReportingType";
  FIX::MultiLegReportingType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MultiLegReportingType *)new FIX::MultiLegReportingType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MultiLegReportingType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MultiLegReportingType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MultiLegReportingType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MultiLegReportingType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultiLegReportingType";
  FIX::MultiLegReportingType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MultiLegReportingType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MultiLegReportingType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MultiLegReportingType *)new FIX::MultiLegReportingType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MultiLegReportingType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MultiLegReportingType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultiLegReportingType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MultiLegReportingType.new", 
    "    MultiLegReportingType.new()\n"
    "    MultiLegReportingType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MultiLegReportingType(FIX::MultiLegReportingType *arg1) {
    delete arg1;
}

swig_class SwigClassIDSource;

SWIGINTERN VALUE
_wrap_new_IDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IDSource";
  FIX::IDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IDSource *)new FIX::IDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IDSource";
  FIX::IDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IDSource *)new FIX::IDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IDSource.new", 
    "    IDSource.new()\n"
    "    IDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IDSource(FIX::IDSource *arg1) {
    delete arg1;
}

swig_class SwigClassLegStipulationType;

SWIGINTERN VALUE
_wrap_new_LegStipulationType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationType";
  FIX::LegStipulationType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegStipulationType *)new FIX::LegStipulationType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegStipulationType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegStipulationType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegStipulationType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegStipulationType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationType";
  FIX::LegStipulationType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegStipulationType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegStipulationType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegStipulationType *)new FIX::LegStipulationType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegStipulationType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegStipulationType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStipulationType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegStipulationType.new", 
    "    LegStipulationType.new()\n"
    "    LegStipulationType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStipulationType(FIX::LegStipulationType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_DerivativeContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplierUnit";
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeContractMultiplierUnit *)new FIX::DerivativeContractMultiplierUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeContractMultiplierUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeContractMultiplierUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeContractMultiplierUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplierUnit";
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeContractMultiplierUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeContractMultiplierUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeContractMultiplierUnit *)new FIX::DerivativeContractMultiplierUnit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeContractMultiplierUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeContractMultiplierUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeContractMultiplierUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeContractMultiplierUnit.new", 
    "    DerivativeContractMultiplierUnit.new()\n"
    "    DerivativeContractMultiplierUnit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeContractMultiplierUnit(FIX::DerivativeContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class SwigClassMarketSegmentID;

SWIGINTERN VALUE
_wrap_new_MarketSegmentID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentID";
  FIX::MarketSegmentID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketSegmentID *)new FIX::MarketSegmentID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketSegmentID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketSegmentID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketSegmentID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketSegmentID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentID";
  FIX::MarketSegmentID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MarketSegmentID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MarketSegmentID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MarketSegmentID *)new FIX::MarketSegmentID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketSegmentID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketSegmentID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketSegmentID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketSegmentID.new", 
    "    MarketSegmentID.new()\n"
    "    MarketSegmentID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketSegmentID(FIX::MarketSegmentID *arg1) {
    delete arg1;
}

swig_class SwigClassOrdStatus;

SWIGINTERN VALUE
_wrap_new_OrdStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrdStatus";
  FIX::OrdStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrdStatus *)new FIX::OrdStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrdStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrdStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrdStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrdStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdStatus";
  FIX::OrdStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OrdStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OrdStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OrdStatus *)new FIX::OrdStatus((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrdStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrdStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrdStatus.new", 
    "    OrdStatus.new()\n"
    "    OrdStatus.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdStatus(FIX::OrdStatus *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityDate;

SWIGINTERN VALUE
_wrap_new_MaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityDate";
  FIX::MaturityDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityDate *)new FIX::MaturityDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityDate";
  FIX::MaturityDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::MaturityDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::MaturityDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::MaturityDate *)new FIX::MaturityDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityDate.new", 
    "    MaturityDate.new()\n"
    "    MaturityDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityDate(FIX::MaturityDate *arg1) {
    delete arg1;
}

swig_class SwigClassApplTotalMessageCount;

SWIGINTERN VALUE
_wrap_new_ApplTotalMessageCount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplTotalMessageCount";
  FIX::ApplTotalMessageCount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplTotalMessageCount *)new FIX::ApplTotalMessageCount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplTotalMessageCount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplTotalMessageCount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplTotalMessageCount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplTotalMessageCount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplTotalMessageCount";
  FIX::ApplTotalMessageCount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplTotalMessageCount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplTotalMessageCount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplTotalMessageCount *)new FIX::ApplTotalMessageCount((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplTotalMessageCount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplTotalMessageCount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplTotalMessageCount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplTotalMessageCount.new", 
    "    ApplTotalMessageCount.new()\n"
    "    ApplTotalMessageCount.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplTotalMessageCount(FIX::ApplTotalMessageCount *arg1) {
    delete arg1;
}

swig_class SwigClassInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_InstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubID";
  FIX::InstrumentPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrumentPartySubID *)new FIX::InstrumentPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrumentPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrumentPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrumentPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrumentPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubID";
  FIX::InstrumentPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::InstrumentPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::InstrumentPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::InstrumentPartySubID *)new FIX::InstrumentPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrumentPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrumentPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrumentPartySubID.new", 
    "    InstrumentPartySubID.new()\n"
    "    InstrumentPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartySubID(FIX::InstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassCustomerOrFirm;

SWIGINTERN VALUE
_wrap_new_CustomerOrFirm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CustomerOrFirm";
  FIX::CustomerOrFirm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CustomerOrFirm *)new FIX::CustomerOrFirm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CustomerOrFirm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CustomerOrFirm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CustomerOrFirm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CustomerOrFirm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustomerOrFirm";
  FIX::CustomerOrFirm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CustomerOrFirm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CustomerOrFirm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CustomerOrFirm *)new FIX::CustomerOrFirm((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CustomerOrFirm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CustomerOrFirm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustomerOrFirm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CustomerOrFirm.new", 
    "    CustomerOrFirm.new()\n"
    "    CustomerOrFirm.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CustomerOrFirm(FIX::CustomerOrFirm *arg1) {
    delete arg1;
}

swig_class SwigClassAdjustmentType;

SWIGINTERN VALUE
_wrap_new_AdjustmentType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AdjustmentType";
  FIX::AdjustmentType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AdjustmentType *)new FIX::AdjustmentType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AdjustmentType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AdjustmentType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AdjustmentType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AdjustmentType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdjustmentType";
  FIX::AdjustmentType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AdjustmentType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AdjustmentType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AdjustmentType *)new FIX::AdjustmentType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AdjustmentType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AdjustmentType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdjustmentType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AdjustmentType.new", 
    "    AdjustmentType.new()\n"
    "    AdjustmentType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AdjustmentType(FIX::AdjustmentType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyID";
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingInstrumentPartyID *)new FIX::UnderlyingInstrumentPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingInstrumentPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingInstrumentPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyID";
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingInstrumentPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingInstrumentPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingInstrumentPartyID *)new FIX::UnderlyingInstrumentPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingInstrumentPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingInstrumentPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingInstrumentPartyID.new", 
    "    UnderlyingInstrumentPartyID.new()\n"
    "    UnderlyingInstrumentPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartyID(FIX::UnderlyingInstrumentPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassAsOfIndicator;

SWIGINTERN VALUE
_wrap_new_AsOfIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AsOfIndicator";
  FIX::AsOfIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AsOfIndicator *)new FIX::AsOfIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AsOfIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AsOfIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AsOfIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AsOfIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AsOfIndicator";
  FIX::AsOfIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::AsOfIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::AsOfIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::AsOfIndicator *)new FIX::AsOfIndicator((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AsOfIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AsOfIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AsOfIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AsOfIndicator.new", 
    "    AsOfIndicator.new()\n"
    "    AsOfIndicator.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AsOfIndicator(FIX::AsOfIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteStatusReqID;

SWIGINTERN VALUE
_wrap_new_QuoteStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatusReqID";
  FIX::QuoteStatusReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteStatusReqID *)new FIX::QuoteStatusReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteStatusReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteStatusReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteStatusReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteStatusReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatusReqID";
  FIX::QuoteStatusReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteStatusReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteStatusReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteStatusReqID *)new FIX::QuoteStatusReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteStatusReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteStatusReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteStatusReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteStatusReqID.new", 
    "    QuoteStatusReqID.new()\n"
    "    QuoteStatusReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteStatusReqID(FIX::QuoteStatusReqID *arg1) {
    delete arg1;
}

swig_class SwigClassLegPositionEffect;

SWIGINTERN VALUE
_wrap_new_LegPositionEffect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPositionEffect";
  FIX::LegPositionEffect *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPositionEffect *)new FIX::LegPositionEffect();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPositionEffect_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPositionEffect_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPositionEffect);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPositionEffect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPositionEffect";
  FIX::LegPositionEffect *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LegPositionEffect", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LegPositionEffect", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LegPositionEffect *)new FIX::LegPositionEffect((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPositionEffect(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPositionEffect__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPositionEffect__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPositionEffect.new", 
    "    LegPositionEffect.new()\n"
    "    LegPositionEffect.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPositionEffect(FIX::LegPositionEffect *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryPx;

SWIGINTERN VALUE
_wrap_new_MDEntryPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPx";
  FIX::MDEntryPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryPx *)new FIX::MDEntryPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPx";
  FIX::MDEntryPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::MDEntryPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::MDEntryPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::MDEntryPx *)new FIX::MDEntryPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryPx.new", 
    "    MDEntryPx.new()\n"
    "    MDEntryPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryPx(FIX::MDEntryPx *arg1) {
    delete arg1;
}

swig_class SwigClassMassActionScope;

SWIGINTERN VALUE
_wrap_new_MassActionScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassActionScope";
  FIX::MassActionScope *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassActionScope *)new FIX::MassActionScope();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassActionScope_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassActionScope_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassActionScope);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassActionScope__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionScope";
  FIX::MassActionScope *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MassActionScope", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MassActionScope", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MassActionScope *)new FIX::MassActionScope((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassActionScope(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassActionScope__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionScope__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassActionScope.new", 
    "    MassActionScope.new()\n"
    "    MassActionScope.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionScope(FIX::MassActionScope *arg1) {
    delete arg1;
}

swig_class SwigClassReportedPxDiff;

SWIGINTERN VALUE
_wrap_new_ReportedPxDiff__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ReportedPxDiff";
  FIX::ReportedPxDiff *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ReportedPxDiff *)new FIX::ReportedPxDiff();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ReportedPxDiff_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ReportedPxDiff_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ReportedPxDiff);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ReportedPxDiff__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportedPxDiff";
  FIX::ReportedPxDiff *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ReportedPxDiff", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ReportedPxDiff", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ReportedPxDiff *)new FIX::ReportedPxDiff((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ReportedPxDiff(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ReportedPxDiff__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReportedPxDiff__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ReportedPxDiff.new", 
    "    ReportedPxDiff.new()\n"
    "    ReportedPxDiff.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ReportedPxDiff(FIX::ReportedPxDiff *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSettlementDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementDate";
  FIX::UnderlyingSettlementDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSettlementDate *)new FIX::UnderlyingSettlementDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSettlementDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSettlementDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSettlementDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementDate";
  FIX::UnderlyingSettlementDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::UnderlyingSettlementDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::UnderlyingSettlementDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::UnderlyingSettlementDate *)new FIX::UnderlyingSettlementDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSettlementDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSettlementDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlementDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSettlementDate.new", 
    "    UnderlyingSettlementDate.new()\n"
    "    UnderlyingSettlementDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlementDate(FIX::UnderlyingSettlementDate *arg1) {
    delete arg1;
}

swig_class SwigClassNoNestedPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNestedPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartySubIDs";
  FIX::NoNestedPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNestedPartySubIDs *)new FIX::NoNestedPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNestedPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNestedPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNestedPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNestedPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartySubIDs";
  FIX::NoNestedPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNestedPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNestedPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNestedPartySubIDs *)new FIX::NoNestedPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNestedPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNestedPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNestedPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNestedPartySubIDs.new", 
    "    NoNestedPartySubIDs.new()\n"
    "    NoNestedPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNestedPartySubIDs(FIX::NoNestedPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassAllocReportRefID;

SWIGINTERN VALUE
_wrap_new_AllocReportRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocReportRefID";
  FIX::AllocReportRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocReportRefID *)new FIX::AllocReportRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocReportRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocReportRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocReportRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocReportRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportRefID";
  FIX::AllocReportRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocReportRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocReportRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocReportRefID *)new FIX::AllocReportRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocReportRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocReportRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocReportRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocReportRefID.new", 
    "    AllocReportRefID.new()\n"
    "    AllocReportRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocReportRefID(FIX::AllocReportRefID *arg1) {
    delete arg1;
}

swig_class SwigClassConcession;

SWIGINTERN VALUE
_wrap_new_Concession__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Concession";
  FIX::Concession *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Concession *)new FIX::Concession();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Concession_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Concession_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Concession);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Concession__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Concession";
  FIX::Concession *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::Concession", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::Concession", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::Concession *)new FIX::Concession((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Concession(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Concession__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Concession__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Concession.new", 
    "    Concession.new()\n"
    "    Concession.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Concession(FIX::Concession *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedSecurityDesc;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDesc";
  FIX::EncodedSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedSecurityDesc *)new FIX::EncodedSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDesc";
  FIX::EncodedSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedSecurityDesc *)new FIX::EncodedSecurityDesc((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedSecurityDesc.new", 
    "    EncodedSecurityDesc.new()\n"
    "    EncodedSecurityDesc.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityDesc(FIX::EncodedSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassExecRefID;

SWIGINTERN VALUE
_wrap_new_ExecRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecRefID";
  FIX::ExecRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecRefID *)new FIX::ExecRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecRefID";
  FIX::ExecRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ExecRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ExecRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ExecRefID *)new FIX::ExecRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecRefID.new", 
    "    ExecRefID.new()\n"
    "    ExecRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecRefID(FIX::ExecRefID *arg1) {
    delete arg1;
}

swig_class SwigClassVenueType;

SWIGINTERN VALUE
_wrap_new_VenueType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::VenueType";
  FIX::VenueType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::VenueType *)new FIX::VenueType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_VenueType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_VenueType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__VenueType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_VenueType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::VenueType";
  FIX::VenueType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::VenueType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::VenueType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::VenueType *)new FIX::VenueType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_VenueType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_VenueType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VenueType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "VenueType.new", 
    "    VenueType.new()\n"
    "    VenueType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_VenueType(FIX::VenueType *arg1) {
    delete arg1;
}

swig_class SwigClassMassActionType;

SWIGINTERN VALUE
_wrap_new_MassActionType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassActionType";
  FIX::MassActionType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassActionType *)new FIX::MassActionType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassActionType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassActionType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassActionType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassActionType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionType";
  FIX::MassActionType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MassActionType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MassActionType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MassActionType *)new FIX::MassActionType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassActionType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassActionType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassActionType.new", 
    "    MassActionType.new()\n"
    "    MassActionType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionType(FIX::MassActionType *arg1) {
    delete arg1;
}

swig_class SwigClassPosMaintResult;

SWIGINTERN VALUE
_wrap_new_PosMaintResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosMaintResult";
  FIX::PosMaintResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosMaintResult *)new FIX::PosMaintResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosMaintResult_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosMaintResult_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosMaintResult);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosMaintResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintResult";
  FIX::PosMaintResult *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosMaintResult", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosMaintResult", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosMaintResult *)new FIX::PosMaintResult((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosMaintResult(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosMaintResult__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintResult__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosMaintResult.new", 
    "    PosMaintResult.new()\n"
    "    PosMaintResult.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintResult(FIX::PosMaintResult *arg1) {
    delete arg1;
}

swig_class SwigClassIOIShares;

SWIGINTERN VALUE
_wrap_new_IOIShares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIShares";
  FIX::IOIShares *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIShares *)new FIX::IOIShares();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIShares_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIShares_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIShares);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIShares__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIShares";
  FIX::IOIShares *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IOIShares", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IOIShares", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IOIShares *)new FIX::IOIShares((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIShares(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIShares__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIShares__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIShares.new", 
    "    IOIShares.new()\n"
    "    IOIShares.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIShares(FIX::IOIShares *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkSecurityID;

SWIGINTERN VALUE
_wrap_new_BenchmarkSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityID";
  FIX::BenchmarkSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkSecurityID *)new FIX::BenchmarkSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityID";
  FIX::BenchmarkSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BenchmarkSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BenchmarkSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BenchmarkSecurityID *)new FIX::BenchmarkSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkSecurityID.new", 
    "    BenchmarkSecurityID.new()\n"
    "    BenchmarkSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkSecurityID(FIX::BenchmarkSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassLegLastQty;

SWIGINTERN VALUE
_wrap_new_LegLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegLastQty";
  FIX::LegLastQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegLastQty *)new FIX::LegLastQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegLastQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegLastQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegLastQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegLastQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastQty";
  FIX::LegLastQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegLastQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegLastQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegLastQty *)new FIX::LegLastQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegLastQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegLastQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLastQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegLastQty.new", 
    "    LegLastQty.new()\n"
    "    LegLastQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLastQty(FIX::LegLastQty *arg1) {
    delete arg1;
}

swig_class SwigClassAllocSettlCurrency;

SWIGINTERN VALUE
_wrap_new_AllocSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrency";
  FIX::AllocSettlCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocSettlCurrency *)new FIX::AllocSettlCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocSettlCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocSettlCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocSettlCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocSettlCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrency";
  FIX::AllocSettlCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::AllocSettlCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::AllocSettlCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::AllocSettlCurrency *)new FIX::AllocSettlCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocSettlCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocSettlCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocSettlCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocSettlCurrency.new", 
    "    AllocSettlCurrency.new()\n"
    "    AllocSettlCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocSettlCurrency(FIX::AllocSettlCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassLegCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_LegCountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCountryOfIssue";
  FIX::LegCountryOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCountryOfIssue *)new FIX::LegCountryOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCountryOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCountryOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCountryOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCountryOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCountryOfIssue";
  FIX::LegCountryOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__COUNTRY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::COUNTRY const &","FIX::LegCountryOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::COUNTRY const &","FIX::LegCountryOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  result = (FIX::LegCountryOfIssue *)new FIX::LegCountryOfIssue((FIX::COUNTRY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCountryOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCountryOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCountryOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCountryOfIssue.new", 
    "    LegCountryOfIssue.new()\n"
    "    LegCountryOfIssue.new(FIX::COUNTRY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCountryOfIssue(FIX::LegCountryOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityXML;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXML__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXML";
  FIX::DerivativeSecurityXML *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityXML *)new FIX::DerivativeSecurityXML();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityXML_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityXML_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityXML);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXML__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXML";
  FIX::DerivativeSecurityXML *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::DerivativeSecurityXML", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::DerivativeSecurityXML", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::DerivativeSecurityXML *)new FIX::DerivativeSecurityXML((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityXML(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityXML__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityXML__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityXML.new", 
    "    DerivativeSecurityXML.new()\n"
    "    DerivativeSecurityXML.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityXML(FIX::DerivativeSecurityXML *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeRuleID;

SWIGINTERN VALUE
_wrap_new_StrikeRuleID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeRuleID";
  FIX::StrikeRuleID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeRuleID *)new FIX::StrikeRuleID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeRuleID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeRuleID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeRuleID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeRuleID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeRuleID";
  FIX::StrikeRuleID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StrikeRuleID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StrikeRuleID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StrikeRuleID *)new FIX::StrikeRuleID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeRuleID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeRuleID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeRuleID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikeRuleID.new", 
    "    StrikeRuleID.new()\n"
    "    StrikeRuleID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeRuleID(FIX::StrikeRuleID *arg1) {
    delete arg1;
}

swig_class SwigClassRefCompID;

SWIGINTERN VALUE
_wrap_new_RefCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefCompID";
  FIX::RefCompID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefCompID *)new FIX::RefCompID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefCompID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefCompID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefCompID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefCompID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefCompID";
  FIX::RefCompID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefCompID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefCompID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefCompID *)new FIX::RefCompID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefCompID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefCompID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefCompID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefCompID.new", 
    "    RefCompID.new()\n"
    "    RefCompID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefCompID(FIX::RefCompID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlCurrOfferFxRate;

SWIGINTERN VALUE
_wrap_new_SettlCurrOfferFxRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrOfferFxRate";
  FIX::SettlCurrOfferFxRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlCurrOfferFxRate *)new FIX::SettlCurrOfferFxRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlCurrOfferFxRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlCurrOfferFxRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlCurrOfferFxRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlCurrOfferFxRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrOfferFxRate";
  FIX::SettlCurrOfferFxRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::SettlCurrOfferFxRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::SettlCurrOfferFxRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::SettlCurrOfferFxRate *)new FIX::SettlCurrOfferFxRate((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlCurrOfferFxRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlCurrOfferFxRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrOfferFxRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlCurrOfferFxRate.new", 
    "    SettlCurrOfferFxRate.new()\n"
    "    SettlCurrOfferFxRate.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrOfferFxRate(FIX::SettlCurrOfferFxRate *arg1) {
    delete arg1;
}

swig_class SwigClassOfferYield;

SWIGINTERN VALUE
_wrap_new_OfferYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferYield";
  FIX::OfferYield *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferYield *)new FIX::OfferYield();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferYield_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferYield_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferYield);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferYield__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferYield";
  FIX::OfferYield *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::OfferYield", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::OfferYield", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::OfferYield *)new FIX::OfferYield((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferYield(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferYield__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferYield__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferYield.new", 
    "    OfferYield.new()\n"
    "    OfferYield.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferYield(FIX::OfferYield *arg1) {
    delete arg1;
}

swig_class SwigClassTargetPartyIDSource;

SWIGINTERN VALUE
_wrap_new_TargetPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyIDSource";
  FIX::TargetPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetPartyIDSource *)new FIX::TargetPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyIDSource";
  FIX::TargetPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TargetPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TargetPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TargetPartyIDSource *)new FIX::TargetPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetPartyIDSource.new", 
    "    TargetPartyIDSource.new()\n"
    "    TargetPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetPartyIDSource(FIX::TargetPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassEncryptedNewPasswordLen;

SWIGINTERN VALUE
_wrap_new_EncryptedNewPasswordLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPasswordLen";
  FIX::EncryptedNewPasswordLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncryptedNewPasswordLen *)new FIX::EncryptedNewPasswordLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncryptedNewPasswordLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncryptedNewPasswordLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncryptedNewPasswordLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncryptedNewPasswordLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPasswordLen";
  FIX::EncryptedNewPasswordLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncryptedNewPasswordLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncryptedNewPasswordLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncryptedNewPasswordLen *)new FIX::EncryptedNewPasswordLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncryptedNewPasswordLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncryptedNewPasswordLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedNewPasswordLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncryptedNewPasswordLen.new", 
    "    EncryptedNewPasswordLen.new()\n"
    "    EncryptedNewPasswordLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedNewPasswordLen(FIX::EncryptedNewPasswordLen *arg1) {
    delete arg1;
}

swig_class SwigClassNoPositions;

SWIGINTERN VALUE
_wrap_new_NoPositions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoPositions";
  FIX::NoPositions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoPositions *)new FIX::NoPositions();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoPositions_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoPositions_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoPositions);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoPositions__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPositions";
  FIX::NoPositions *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoPositions", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoPositions", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPositions *)new FIX::NoPositions((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPositions(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPositions__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPositions__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoPositions.new", 
    "    NoPositions.new()\n"
    "    NoPositions.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPositions(FIX::NoPositions *arg1) {
    delete arg1;
}

swig_class SwigClassTotalAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_TotalAccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalAccruedInterestAmt";
  FIX::TotalAccruedInterestAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalAccruedInterestAmt *)new FIX::TotalAccruedInterestAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalAccruedInterestAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalAccruedInterestAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalAccruedInterestAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalAccruedInterestAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalAccruedInterestAmt";
  FIX::TotalAccruedInterestAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::TotalAccruedInterestAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::TotalAccruedInterestAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::TotalAccruedInterestAmt *)new FIX::TotalAccruedInterestAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalAccruedInterestAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalAccruedInterestAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalAccruedInterestAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalAccruedInterestAmt.new", 
    "    TotalAccruedInterestAmt.new()\n"
    "    TotalAccruedInterestAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalAccruedInterestAmt(FIX::TotalAccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingOptAttribute;

SWIGINTERN VALUE
_wrap_new_UnderlyingOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOptAttribute";
  FIX::UnderlyingOptAttribute *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingOptAttribute *)new FIX::UnderlyingOptAttribute();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingOptAttribute_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingOptAttribute_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingOptAttribute);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingOptAttribute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOptAttribute";
  FIX::UnderlyingOptAttribute *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::UnderlyingOptAttribute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::UnderlyingOptAttribute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::UnderlyingOptAttribute *)new FIX::UnderlyingOptAttribute((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingOptAttribute(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingOptAttribute__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingOptAttribute__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingOptAttribute.new", 
    "    UnderlyingOptAttribute.new()\n"
    "    UnderlyingOptAttribute.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingOptAttribute(FIX::UnderlyingOptAttribute *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrAttribValue;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrAttribValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribValue";
  FIX::DerivativeInstrAttribValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrAttribValue *)new FIX::DerivativeInstrAttribValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrAttribValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrAttribValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrAttribValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrAttribValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribValue";
  FIX::DerivativeInstrAttribValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeInstrAttribValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeInstrAttribValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeInstrAttribValue *)new FIX::DerivativeInstrAttribValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrAttribValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrAttribValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrAttribValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrAttribValue.new", 
    "    DerivativeInstrAttribValue.new()\n"
    "    DerivativeInstrAttribValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrAttribValue(FIX::DerivativeInstrAttribValue *arg1) {
    delete arg1;
}

swig_class SwigClassInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_InstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyIDSource";
  FIX::InstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrumentPartyIDSource *)new FIX::InstrumentPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrumentPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrumentPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrumentPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrumentPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyIDSource";
  FIX::InstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::InstrumentPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::InstrumentPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::InstrumentPartyIDSource *)new FIX::InstrumentPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrumentPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrumentPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrumentPartyIDSource.new", 
    "    InstrumentPartyIDSource.new()\n"
    "    InstrumentPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartyIDSource(FIX::InstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassPegOffsetType;

SWIGINTERN VALUE
_wrap_new_PegOffsetType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetType";
  FIX::PegOffsetType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegOffsetType *)new FIX::PegOffsetType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegOffsetType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegOffsetType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegOffsetType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegOffsetType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetType";
  FIX::PegOffsetType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PegOffsetType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PegOffsetType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PegOffsetType *)new FIX::PegOffsetType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegOffsetType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegOffsetType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegOffsetType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegOffsetType.new", 
    "    PegOffsetType.new()\n"
    "    PegOffsetType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegOffsetType(FIX::PegOffsetType *arg1) {
    delete arg1;
}

swig_class SwigClassMassCancelRejectReason;

SWIGINTERN VALUE
_wrap_new_MassCancelRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRejectReason";
  FIX::MassCancelRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassCancelRejectReason *)new FIX::MassCancelRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassCancelRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassCancelRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassCancelRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassCancelRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRejectReason";
  FIX::MassCancelRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MassCancelRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MassCancelRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MassCancelRejectReason *)new FIX::MassCancelRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassCancelRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassCancelRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassCancelRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassCancelRejectReason.new", 
    "    MassCancelRejectReason.new()\n"
    "    MassCancelRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassCancelRejectReason(FIX::MassCancelRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassResponseTransportType;

SWIGINTERN VALUE
_wrap_new_ResponseTransportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ResponseTransportType";
  FIX::ResponseTransportType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ResponseTransportType *)new FIX::ResponseTransportType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ResponseTransportType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ResponseTransportType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ResponseTransportType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ResponseTransportType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResponseTransportType";
  FIX::ResponseTransportType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ResponseTransportType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ResponseTransportType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ResponseTransportType *)new FIX::ResponseTransportType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ResponseTransportType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ResponseTransportType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResponseTransportType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ResponseTransportType.new", 
    "    ResponseTransportType.new()\n"
    "    ResponseTransportType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ResponseTransportType(FIX::ResponseTransportType *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_LegSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityIDSource";
  FIX::LegSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityIDSource *)new FIX::LegSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityIDSource";
  FIX::LegSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecurityIDSource *)new FIX::LegSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityIDSource.new", 
    "    LegSecurityIDSource.new()\n"
    "    LegSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityIDSource(FIX::LegSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassBasisFeaturePrice;

SWIGINTERN VALUE
_wrap_new_BasisFeaturePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BasisFeaturePrice";
  FIX::BasisFeaturePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BasisFeaturePrice *)new FIX::BasisFeaturePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BasisFeaturePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BasisFeaturePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BasisFeaturePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BasisFeaturePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisFeaturePrice";
  FIX::BasisFeaturePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::BasisFeaturePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::BasisFeaturePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::BasisFeaturePrice *)new FIX::BasisFeaturePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BasisFeaturePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BasisFeaturePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BasisFeaturePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BasisFeaturePrice.new", 
    "    BasisFeaturePrice.new()\n"
    "    BasisFeaturePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BasisFeaturePrice(FIX::BasisFeaturePrice *arg1) {
    delete arg1;
}

swig_class SwigClassCouponPaymentDate;

SWIGINTERN VALUE
_wrap_new_CouponPaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CouponPaymentDate";
  FIX::CouponPaymentDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CouponPaymentDate *)new FIX::CouponPaymentDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CouponPaymentDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CouponPaymentDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CouponPaymentDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CouponPaymentDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CouponPaymentDate";
  FIX::CouponPaymentDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::CouponPaymentDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::CouponPaymentDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::CouponPaymentDate *)new FIX::CouponPaymentDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CouponPaymentDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CouponPaymentDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CouponPaymentDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CouponPaymentDate.new", 
    "    CouponPaymentDate.new()\n"
    "    CouponPaymentDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CouponPaymentDate(FIX::CouponPaymentDate *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesStatusRejReason;

SWIGINTERN VALUE
_wrap_new_TradSesStatusRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatusRejReason";
  FIX::TradSesStatusRejReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesStatusRejReason *)new FIX::TradSesStatusRejReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesStatusRejReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesStatusRejReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesStatusRejReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesStatusRejReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatusRejReason";
  FIX::TradSesStatusRejReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradSesStatusRejReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradSesStatusRejReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradSesStatusRejReason *)new FIX::TradSesStatusRejReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesStatusRejReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesStatusRejReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesStatusRejReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesStatusRejReason.new", 
    "    TradSesStatusRejReason.new()\n"
    "    TradSesStatusRejReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesStatusRejReason(FIX::TradSesStatusRejReason *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingDetachmentPoint;

SWIGINTERN VALUE
_wrap_new_UnderlyingDetachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDetachmentPoint";
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingDetachmentPoint *)new FIX::UnderlyingDetachmentPoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingDetachmentPoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingDetachmentPoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingDetachmentPoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingDetachmentPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDetachmentPoint";
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingDetachmentPoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingDetachmentPoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingDetachmentPoint *)new FIX::UnderlyingDetachmentPoint((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingDetachmentPoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingDetachmentPoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingDetachmentPoint__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingDetachmentPoint.new", 
    "    UnderlyingDetachmentPoint.new()\n"
    "    UnderlyingDetachmentPoint.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingDetachmentPoint(FIX::UnderlyingDetachmentPoint *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityRuleID;

SWIGINTERN VALUE
_wrap_new_MaturityRuleID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityRuleID";
  FIX::MaturityRuleID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityRuleID *)new FIX::MaturityRuleID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityRuleID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityRuleID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityRuleID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityRuleID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityRuleID";
  FIX::MaturityRuleID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MaturityRuleID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MaturityRuleID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MaturityRuleID *)new FIX::MaturityRuleID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityRuleID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityRuleID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityRuleID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityRuleID.new", 
    "    MaturityRuleID.new()\n"
    "    MaturityRuleID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityRuleID(FIX::MaturityRuleID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingRepoCollateralSecurityType;

SWIGINTERN VALUE
_wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepoCollateralSecurityType";
  FIX::UnderlyingRepoCollateralSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingRepoCollateralSecurityType *)new FIX::UnderlyingRepoCollateralSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingRepoCollateralSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingRepoCollateralSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepoCollateralSecurityType";
  FIX::UnderlyingRepoCollateralSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingRepoCollateralSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingRepoCollateralSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingRepoCollateralSecurityType *)new FIX::UnderlyingRepoCollateralSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingRepoCollateralSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingRepoCollateralSecurityType.new", 
    "    UnderlyingRepoCollateralSecurityType.new()\n"
    "    UnderlyingRepoCollateralSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRepoCollateralSecurityType(FIX::UnderlyingRepoCollateralSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassNoTimeInForceRules;

SWIGINTERN VALUE
_wrap_new_NoTimeInForceRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTimeInForceRules";
  FIX::NoTimeInForceRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTimeInForceRules *)new FIX::NoTimeInForceRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTimeInForceRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTimeInForceRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTimeInForceRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTimeInForceRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTimeInForceRules";
  FIX::NoTimeInForceRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTimeInForceRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTimeInForceRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTimeInForceRules *)new FIX::NoTimeInForceRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTimeInForceRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTimeInForceRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTimeInForceRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTimeInForceRules.new", 
    "    NoTimeInForceRules.new()\n"
    "    NoTimeInForceRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTimeInForceRules(FIX::NoTimeInForceRules *arg1) {
    delete arg1;
}

swig_class SwigClassNoRootPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoRootPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartySubIDs";
  FIX::NoRootPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRootPartySubIDs *)new FIX::NoRootPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRootPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRootPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRootPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRootPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartySubIDs";
  FIX::NoRootPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoRootPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoRootPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRootPartySubIDs *)new FIX::NoRootPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRootPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRootPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRootPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRootPartySubIDs.new", 
    "    NoRootPartySubIDs.new()\n"
    "    NoRootPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRootPartySubIDs(FIX::NoRootPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassDisplayMinIncr;

SWIGINTERN VALUE
_wrap_new_DisplayMinIncr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DisplayMinIncr";
  FIX::DisplayMinIncr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DisplayMinIncr *)new FIX::DisplayMinIncr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DisplayMinIncr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DisplayMinIncr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DisplayMinIncr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DisplayMinIncr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayMinIncr";
  FIX::DisplayMinIncr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DisplayMinIncr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DisplayMinIncr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DisplayMinIncr *)new FIX::DisplayMinIncr((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DisplayMinIncr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DisplayMinIncr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayMinIncr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DisplayMinIncr.new", 
    "    DisplayMinIncr.new()\n"
    "    DisplayMinIncr.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayMinIncr(FIX::DisplayMinIncr *arg1) {
    delete arg1;
}

swig_class SwigClassTrdRegTimestampType;

SWIGINTERN VALUE
_wrap_new_TrdRegTimestampType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampType";
  FIX::TrdRegTimestampType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdRegTimestampType *)new FIX::TrdRegTimestampType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdRegTimestampType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdRegTimestampType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdRegTimestampType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdRegTimestampType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampType";
  FIX::TrdRegTimestampType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TrdRegTimestampType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TrdRegTimestampType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TrdRegTimestampType *)new FIX::TrdRegTimestampType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdRegTimestampType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdRegTimestampType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRegTimestampType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdRegTimestampType.new", 
    "    TrdRegTimestampType.new()\n"
    "    TrdRegTimestampType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRegTimestampType(FIX::TrdRegTimestampType *arg1) {
    delete arg1;
}

swig_class SwigClassLegProduct;

SWIGINTERN VALUE
_wrap_new_LegProduct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegProduct";
  FIX::LegProduct *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegProduct *)new FIX::LegProduct();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegProduct_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegProduct_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegProduct);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegProduct__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegProduct";
  FIX::LegProduct *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegProduct", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegProduct", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegProduct *)new FIX::LegProduct((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegProduct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegProduct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegProduct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegProduct.new", 
    "    LegProduct.new()\n"
    "    LegProduct.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegProduct(FIX::LegProduct *arg1) {
    delete arg1;
}

swig_class SwigClassApplVerID;

SWIGINTERN VALUE
_wrap_new_ApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplVerID";
  FIX::ApplVerID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplVerID *)new FIX::ApplVerID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplVerID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplVerID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplVerID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplVerID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplVerID";
  FIX::ApplVerID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ApplVerID *)new FIX::ApplVerID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplVerID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplVerID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplVerID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplVerID.new", 
    "    ApplVerID.new()\n"
    "    ApplVerID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplVerID(FIX::ApplVerID *arg1) {
    delete arg1;
}

swig_class SwigClassHandlInst;

SWIGINTERN VALUE
_wrap_new_HandlInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HandlInst";
  FIX::HandlInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HandlInst *)new FIX::HandlInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HandlInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HandlInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HandlInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HandlInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HandlInst";
  FIX::HandlInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::HandlInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::HandlInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::HandlInst *)new FIX::HandlInst((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HandlInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HandlInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HandlInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HandlInst.new", 
    "    HandlInst.new()\n"
    "    HandlInst.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HandlInst(FIX::HandlInst *arg1) {
    delete arg1;
}

swig_class SwigClassListUpdateAction;

SWIGINTERN VALUE
_wrap_new_ListUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListUpdateAction";
  FIX::ListUpdateAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListUpdateAction *)new FIX::ListUpdateAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListUpdateAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListUpdateAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListUpdateAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListUpdateAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListUpdateAction";
  FIX::ListUpdateAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ListUpdateAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ListUpdateAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ListUpdateAction *)new FIX::ListUpdateAction((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListUpdateAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListUpdateAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListUpdateAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListUpdateAction.new", 
    "    ListUpdateAction.new()\n"
    "    ListUpdateAction.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListUpdateAction(FIX::ListUpdateAction *arg1) {
    delete arg1;
}

swig_class SwigClassNestedInstrAttribValue;

SWIGINTERN VALUE
_wrap_new_NestedInstrAttribValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribValue";
  FIX::NestedInstrAttribValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedInstrAttribValue *)new FIX::NestedInstrAttribValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedInstrAttribValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedInstrAttribValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedInstrAttribValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedInstrAttribValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribValue";
  FIX::NestedInstrAttribValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NestedInstrAttribValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NestedInstrAttribValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NestedInstrAttribValue *)new FIX::NestedInstrAttribValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedInstrAttribValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedInstrAttribValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedInstrAttribValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedInstrAttribValue.new", 
    "    NestedInstrAttribValue.new()\n"
    "    NestedInstrAttribValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedInstrAttribValue(FIX::NestedInstrAttribValue *arg1) {
    delete arg1;
}

swig_class SwigClassTradingSessionSubID;

SWIGINTERN VALUE
_wrap_new_TradingSessionSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionSubID";
  FIX::TradingSessionSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradingSessionSubID *)new FIX::TradingSessionSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradingSessionSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradingSessionSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradingSessionSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradingSessionSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionSubID";
  FIX::TradingSessionSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradingSessionSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradingSessionSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradingSessionSubID *)new FIX::TradingSessionSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradingSessionSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradingSessionSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingSessionSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradingSessionSubID.new", 
    "    TradingSessionSubID.new()\n"
    "    TradingSessionSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingSessionSubID(FIX::TradingSessionSubID *arg1) {
    delete arg1;
}

swig_class SwigClassRFQReqID;

SWIGINTERN VALUE
_wrap_new_RFQReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RFQReqID";
  FIX::RFQReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RFQReqID *)new FIX::RFQReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RFQReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RFQReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RFQReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RFQReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RFQReqID";
  FIX::RFQReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RFQReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RFQReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RFQReqID *)new FIX::RFQReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RFQReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RFQReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RFQReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RFQReqID.new", 
    "    RFQReqID.new()\n"
    "    RFQReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RFQReqID(FIX::RFQReqID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSymbolSfx;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbolSfx";
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSymbolSfx *)new FIX::UnderlyingLegSymbolSfx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSymbolSfx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSymbolSfx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSymbolSfx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbolSfx";
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSymbolSfx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSymbolSfx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSymbolSfx *)new FIX::UnderlyingLegSymbolSfx((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSymbolSfx.new", 
    "    UnderlyingLegSymbolSfx.new()\n"
    "    UnderlyingLegSymbolSfx.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSymbolSfx(FIX::UnderlyingLegSymbolSfx *arg1) {
    delete arg1;
}

swig_class SwigClassLiquidityNumSecurities;

SWIGINTERN VALUE
_wrap_new_LiquidityNumSecurities__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LiquidityNumSecurities";
  FIX::LiquidityNumSecurities *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LiquidityNumSecurities *)new FIX::LiquidityNumSecurities();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LiquidityNumSecurities_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LiquidityNumSecurities_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LiquidityNumSecurities);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LiquidityNumSecurities__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityNumSecurities";
  FIX::LiquidityNumSecurities *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LiquidityNumSecurities", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LiquidityNumSecurities", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LiquidityNumSecurities *)new FIX::LiquidityNumSecurities((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LiquidityNumSecurities(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LiquidityNumSecurities__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityNumSecurities__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LiquidityNumSecurities.new", 
    "    LiquidityNumSecurities.new()\n"
    "    LiquidityNumSecurities.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityNumSecurities(FIX::LiquidityNumSecurities *arg1) {
    delete arg1;
}

swig_class SwigClassNoMsgTypes;

SWIGINTERN VALUE
_wrap_new_NoMsgTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMsgTypes";
  FIX::NoMsgTypes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMsgTypes *)new FIX::NoMsgTypes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMsgTypes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMsgTypes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMsgTypes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMsgTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMsgTypes";
  FIX::NoMsgTypes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMsgTypes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMsgTypes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMsgTypes *)new FIX::NoMsgTypes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMsgTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMsgTypes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMsgTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMsgTypes.new", 
    "    NoMsgTypes.new()\n"
    "    NoMsgTypes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMsgTypes(FIX::NoMsgTypes *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesStartTime;

SWIGINTERN VALUE
_wrap_new_TradSesStartTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  FIX::TradSesStartTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesStartTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  FIX::TradSesStartTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TradSesStartTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesStartTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  FIX::TradSesStartTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesStartTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesStartTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesStartTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesStartTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesStartTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesStartTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  FIX::TradSesStartTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesStartTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesStartTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TradSesStartTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesStartTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesStartTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesStartTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TradSesStartTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesStartTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TradSesStartTime.new", 
    "    TradSesStartTime.new()\n"
    "    TradSesStartTime.new(bool showMilliseconds)\n"
    "    TradSesStartTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TradSesStartTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesStartTime(FIX::TradSesStartTime *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryType;

SWIGINTERN VALUE
_wrap_new_MDEntryType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryType";
  FIX::MDEntryType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryType *)new FIX::MDEntryType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryType";
  FIX::MDEntryType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MDEntryType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MDEntryType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MDEntryType *)new FIX::MDEntryType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryType.new", 
    "    MDEntryType.new()\n"
    "    MDEntryType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryType(FIX::MDEntryType *arg1) {
    delete arg1;
}

swig_class SwigClassAgreementCurrency;

SWIGINTERN VALUE
_wrap_new_AgreementCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AgreementCurrency";
  FIX::AgreementCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AgreementCurrency *)new FIX::AgreementCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AgreementCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AgreementCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AgreementCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AgreementCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementCurrency";
  FIX::AgreementCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::AgreementCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::AgreementCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::AgreementCurrency *)new FIX::AgreementCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AgreementCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AgreementCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AgreementCurrency.new", 
    "    AgreementCurrency.new()\n"
    "    AgreementCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementCurrency(FIX::AgreementCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassPegMoveType;

SWIGINTERN VALUE
_wrap_new_PegMoveType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegMoveType";
  FIX::PegMoveType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegMoveType *)new FIX::PegMoveType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegMoveType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegMoveType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegMoveType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegMoveType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegMoveType";
  FIX::PegMoveType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PegMoveType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PegMoveType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PegMoveType *)new FIX::PegMoveType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegMoveType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegMoveType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegMoveType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegMoveType.new", 
    "    PegMoveType.new()\n"
    "    PegMoveType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegMoveType(FIX::PegMoveType *arg1) {
    delete arg1;
}

swig_class SwigClassPegDifference;

SWIGINTERN VALUE
_wrap_new_PegDifference__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegDifference";
  FIX::PegDifference *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegDifference *)new FIX::PegDifference();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegDifference_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegDifference_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegDifference);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegDifference__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegDifference";
  FIX::PegDifference *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::PegDifference", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::PegDifference", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::PegDifference *)new FIX::PegDifference((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegDifference(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegDifference__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegDifference__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegDifference.new", 
    "    PegDifference.new()\n"
    "    PegDifference.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegDifference(FIX::PegDifference *arg1) {
    delete arg1;
}

swig_class SwigClassSpread;

SWIGINTERN VALUE
_wrap_new_Spread__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Spread";
  FIX::Spread *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Spread *)new FIX::Spread();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Spread_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Spread_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Spread);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Spread__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Spread";
  FIX::Spread *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::Spread", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::Spread", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::Spread *)new FIX::Spread((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Spread(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Spread__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Spread__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Spread.new", 
    "    Spread.new()\n"
    "    Spread.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Spread(FIX::Spread *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedAllocTextLen;

SWIGINTERN VALUE
_wrap_new_EncodedAllocTextLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocTextLen";
  FIX::EncodedAllocTextLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedAllocTextLen *)new FIX::EncodedAllocTextLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedAllocTextLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedAllocTextLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedAllocTextLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedAllocTextLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocTextLen";
  FIX::EncodedAllocTextLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedAllocTextLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedAllocTextLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedAllocTextLen *)new FIX::EncodedAllocTextLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedAllocTextLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedAllocTextLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedAllocTextLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedAllocTextLen.new", 
    "    EncodedAllocTextLen.new()\n"
    "    EncodedAllocTextLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedAllocTextLen(FIX::EncodedAllocTextLen *arg1) {
    delete arg1;
}

swig_class SwigClassOutsideIndexPct;

SWIGINTERN VALUE
_wrap_new_OutsideIndexPct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OutsideIndexPct";
  FIX::OutsideIndexPct *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OutsideIndexPct *)new FIX::OutsideIndexPct();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OutsideIndexPct_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OutsideIndexPct_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OutsideIndexPct);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OutsideIndexPct__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OutsideIndexPct";
  FIX::OutsideIndexPct *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::OutsideIndexPct", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::OutsideIndexPct", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::OutsideIndexPct *)new FIX::OutsideIndexPct((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OutsideIndexPct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OutsideIndexPct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutsideIndexPct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OutsideIndexPct.new", 
    "    OutsideIndexPct.new()\n"
    "    OutsideIndexPct.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OutsideIndexPct(FIX::OutsideIndexPct *arg1) {
    delete arg1;
}

swig_class SwigClassDerivFlexProductEligibilityIndicator;

SWIGINTERN VALUE
_wrap_new_DerivFlexProductEligibilityIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivFlexProductEligibilityIndicator";
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivFlexProductEligibilityIndicator *)new FIX::DerivFlexProductEligibilityIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivFlexProductEligibilityIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivFlexProductEligibilityIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivFlexProductEligibilityIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivFlexProductEligibilityIndicator";
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::DerivFlexProductEligibilityIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::DerivFlexProductEligibilityIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::DerivFlexProductEligibilityIndicator *)new FIX::DerivFlexProductEligibilityIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivFlexProductEligibilityIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivFlexProductEligibilityIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivFlexProductEligibilityIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivFlexProductEligibilityIndicator.new", 
    "    DerivFlexProductEligibilityIndicator.new()\n"
    "    DerivFlexProductEligibilityIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivFlexProductEligibilityIndicator(FIX::DerivFlexProductEligibilityIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassAvgPxIndicator;

SWIGINTERN VALUE
_wrap_new_AvgPxIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AvgPxIndicator";
  FIX::AvgPxIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AvgPxIndicator *)new FIX::AvgPxIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AvgPxIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AvgPxIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AvgPxIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AvgPxIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPxIndicator";
  FIX::AvgPxIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AvgPxIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AvgPxIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AvgPxIndicator *)new FIX::AvgPxIndicator((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AvgPxIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AvgPxIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPxIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AvgPxIndicator.new", 
    "    AvgPxIndicator.new()\n"
    "    AvgPxIndicator.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPxIndicator(FIX::AvgPxIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassNoIOIQualifiers;

SWIGINTERN VALUE
_wrap_new_NoIOIQualifiers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoIOIQualifiers";
  FIX::NoIOIQualifiers *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoIOIQualifiers *)new FIX::NoIOIQualifiers();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoIOIQualifiers_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoIOIQualifiers_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoIOIQualifiers);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoIOIQualifiers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoIOIQualifiers";
  FIX::NoIOIQualifiers *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoIOIQualifiers", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoIOIQualifiers", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoIOIQualifiers *)new FIX::NoIOIQualifiers((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoIOIQualifiers(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoIOIQualifiers__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoIOIQualifiers__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoIOIQualifiers.new", 
    "    NoIOIQualifiers.new()\n"
    "    NoIOIQualifiers.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoIOIQualifiers(FIX::NoIOIQualifiers *arg1) {
    delete arg1;
}

swig_class SwigClassCancellationRights;

SWIGINTERN VALUE
_wrap_new_CancellationRights__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CancellationRights";
  FIX::CancellationRights *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CancellationRights *)new FIX::CancellationRights();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CancellationRights_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CancellationRights_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CancellationRights);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CancellationRights__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CancellationRights";
  FIX::CancellationRights *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::CancellationRights", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::CancellationRights", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::CancellationRights *)new FIX::CancellationRights((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CancellationRights(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CancellationRights__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CancellationRights__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CancellationRights.new", 
    "    CancellationRights.new()\n"
    "    CancellationRights.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CancellationRights(FIX::CancellationRights *arg1) {
    delete arg1;
}

swig_class SwigClassListSeqNo;

SWIGINTERN VALUE
_wrap_new_ListSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListSeqNo";
  FIX::ListSeqNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListSeqNo *)new FIX::ListSeqNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListSeqNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListSeqNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListSeqNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListSeqNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListSeqNo";
  FIX::ListSeqNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ListSeqNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ListSeqNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ListSeqNo *)new FIX::ListSeqNo((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListSeqNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListSeqNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListSeqNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListSeqNo.new", 
    "    ListSeqNo.new()\n"
    "    ListSeqNo.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListSeqNo(FIX::ListSeqNo *arg1) {
    delete arg1;
}

swig_class SwigClassCardIssNum;

SWIGINTERN VALUE
_wrap_new_CardIssNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CardIssNum";
  FIX::CardIssNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CardIssNum *)new FIX::CardIssNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CardIssNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CardIssNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CardIssNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CardIssNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardIssNum";
  FIX::CardIssNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CardIssNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CardIssNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CardIssNum *)new FIX::CardIssNum((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CardIssNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CardIssNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardIssNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CardIssNum.new", 
    "    CardIssNum.new()\n"
    "    CardIssNum.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CardIssNum(FIX::CardIssNum *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedMktSegmDesc;

SWIGINTERN VALUE
_wrap_new_EncodedMktSegmDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDesc";
  FIX::EncodedMktSegmDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedMktSegmDesc *)new FIX::EncodedMktSegmDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedMktSegmDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedMktSegmDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedMktSegmDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedMktSegmDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDesc";
  FIX::EncodedMktSegmDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedMktSegmDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedMktSegmDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedMktSegmDesc *)new FIX::EncodedMktSegmDesc((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedMktSegmDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedMktSegmDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedMktSegmDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedMktSegmDesc.new", 
    "    EncodedMktSegmDesc.new()\n"
    "    EncodedMktSegmDesc.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedMktSegmDesc(FIX::EncodedMktSegmDesc *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEventType;

SWIGINTERN VALUE
_wrap_new_DerivativeEventType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventType";
  FIX::DerivativeEventType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEventType *)new FIX::DerivativeEventType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEventType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEventType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEventType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEventType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventType";
  FIX::DerivativeEventType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeEventType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeEventType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeEventType *)new FIX::DerivativeEventType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEventType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEventType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEventType.new", 
    "    DerivativeEventType.new()\n"
    "    DerivativeEventType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventType(FIX::DerivativeEventType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityMonthYear";
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeMaturityMonthYear *)new FIX::DerivativeMaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeMaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeMaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeMaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityMonthYear";
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::DerivativeMaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::DerivativeMaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::DerivativeMaturityMonthYear *)new FIX::DerivativeMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeMaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeMaturityMonthYear.new", 
    "    DerivativeMaturityMonthYear.new()\n"
    "    DerivativeMaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMaturityMonthYear(FIX::DerivativeMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassSideTradeReportID;

SWIGINTERN VALUE
_wrap_new_SideTradeReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideTradeReportID";
  FIX::SideTradeReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideTradeReportID *)new FIX::SideTradeReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideTradeReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideTradeReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideTradeReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideTradeReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTradeReportID";
  FIX::SideTradeReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SideTradeReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SideTradeReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SideTradeReportID *)new FIX::SideTradeReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideTradeReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideTradeReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTradeReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideTradeReportID.new", 
    "    SideTradeReportID.new()\n"
    "    SideTradeReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTradeReportID(FIX::SideTradeReportID *arg1) {
    delete arg1;
}

swig_class SwigClassNoQuoteSets;

SWIGINTERN VALUE
_wrap_new_NoQuoteSets__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteSets";
  FIX::NoQuoteSets *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoQuoteSets *)new FIX::NoQuoteSets();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoQuoteSets_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoQuoteSets_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoQuoteSets);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoQuoteSets__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteSets";
  FIX::NoQuoteSets *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoQuoteSets", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoQuoteSets", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoQuoteSets *)new FIX::NoQuoteSets((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoQuoteSets(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoQuoteSets__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoQuoteSets__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoQuoteSets.new", 
    "    NoQuoteSets.new()\n"
    "    NoQuoteSets.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoQuoteSets(FIX::NoQuoteSets *arg1) {
    delete arg1;
}

swig_class SwigClassNested4PartySubIDType;

SWIGINTERN VALUE
_wrap_new_Nested4PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubIDType";
  FIX::Nested4PartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested4PartySubIDType *)new FIX::Nested4PartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested4PartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested4PartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested4PartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested4PartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubIDType";
  FIX::Nested4PartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Nested4PartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Nested4PartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Nested4PartySubIDType *)new FIX::Nested4PartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested4PartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested4PartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested4PartySubIDType.new", 
    "    Nested4PartySubIDType.new()\n"
    "    Nested4PartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartySubIDType(FIX::Nested4PartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassFillPx;

SWIGINTERN VALUE
_wrap_new_FillPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FillPx";
  FIX::FillPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FillPx *)new FIX::FillPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FillPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FillPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FillPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FillPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillPx";
  FIX::FillPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::FillPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::FillPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::FillPx *)new FIX::FillPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FillPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FillPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FillPx.new", 
    "    FillPx.new()\n"
    "    FillPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FillPx(FIX::FillPx *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeExerciseStyle;

SWIGINTERN VALUE
_wrap_new_StrikeExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeExerciseStyle";
  FIX::StrikeExerciseStyle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeExerciseStyle *)new FIX::StrikeExerciseStyle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeExerciseStyle_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeExerciseStyle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeExerciseStyle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeExerciseStyle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeExerciseStyle";
  FIX::StrikeExerciseStyle *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StrikeExerciseStyle", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StrikeExerciseStyle", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StrikeExerciseStyle *)new FIX::StrikeExerciseStyle((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeExerciseStyle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeExerciseStyle__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeExerciseStyle__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikeExerciseStyle.new", 
    "    StrikeExerciseStyle.new()\n"
    "    StrikeExerciseStyle.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeExerciseStyle(FIX::StrikeExerciseStyle *arg1) {
    delete arg1;
}

swig_class SwigClassDeskID;

SWIGINTERN VALUE
_wrap_new_DeskID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeskID";
  FIX::DeskID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeskID *)new FIX::DeskID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeskID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeskID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeskID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeskID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskID";
  FIX::DeskID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DeskID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DeskID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DeskID *)new FIX::DeskID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeskID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeskID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeskID.new", 
    "    DeskID.new()\n"
    "    DeskID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskID(FIX::DeskID *arg1) {
    delete arg1;
}

swig_class SwigClassCrossPercent;

SWIGINTERN VALUE
_wrap_new_CrossPercent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CrossPercent";
  FIX::CrossPercent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CrossPercent *)new FIX::CrossPercent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CrossPercent_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CrossPercent_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CrossPercent);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CrossPercent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossPercent";
  FIX::CrossPercent *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::CrossPercent", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::CrossPercent", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::CrossPercent *)new FIX::CrossPercent((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CrossPercent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CrossPercent__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossPercent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CrossPercent.new", 
    "    CrossPercent.new()\n"
    "    CrossPercent.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossPercent(FIX::CrossPercent *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYear";
  FIX::MaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityMonthYear *)new FIX::MaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYear";
  FIX::MaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::MaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::MaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::MaturityMonthYear *)new FIX::MaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityMonthYear.new", 
    "    MaturityMonthYear.new()\n"
    "    MaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYear(FIX::MaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventPrice;

SWIGINTERN VALUE
_wrap_new_ComplexEventPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPrice";
  FIX::ComplexEventPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventPrice *)new FIX::ComplexEventPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPrice";
  FIX::ComplexEventPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::ComplexEventPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::ComplexEventPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::ComplexEventPrice *)new FIX::ComplexEventPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventPrice.new", 
    "    ComplexEventPrice.new()\n"
    "    ComplexEventPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPrice(FIX::ComplexEventPrice *arg1) {
    delete arg1;
}

swig_class SwigClassNoNewsRefIDs;

SWIGINTERN VALUE
_wrap_new_NoNewsRefIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNewsRefIDs";
  FIX::NoNewsRefIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNewsRefIDs *)new FIX::NoNewsRefIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNewsRefIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNewsRefIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNewsRefIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNewsRefIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNewsRefIDs";
  FIX::NoNewsRefIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNewsRefIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNewsRefIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNewsRefIDs *)new FIX::NoNewsRefIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNewsRefIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNewsRefIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNewsRefIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNewsRefIDs.new", 
    "    NoNewsRefIDs.new()\n"
    "    NoNewsRefIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNewsRefIDs(FIX::NoNewsRefIDs *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCapValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingCapValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCapValue";
  FIX::UnderlyingCapValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCapValue *)new FIX::UnderlyingCapValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCapValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCapValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCapValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCapValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCapValue";
  FIX::UnderlyingCapValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingCapValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingCapValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingCapValue *)new FIX::UnderlyingCapValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCapValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCapValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCapValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCapValue.new", 
    "    UnderlyingCapValue.new()\n"
    "    UnderlyingCapValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCapValue(FIX::UnderlyingCapValue *arg1) {
    delete arg1;
}

swig_class SwigClassCPRegType;

SWIGINTERN VALUE
_wrap_new_CPRegType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CPRegType";
  FIX::CPRegType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CPRegType *)new FIX::CPRegType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CPRegType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CPRegType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CPRegType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CPRegType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CPRegType";
  FIX::CPRegType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CPRegType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CPRegType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CPRegType *)new FIX::CPRegType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CPRegType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CPRegType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CPRegType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CPRegType.new", 
    "    CPRegType.new()\n"
    "    CPRegType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CPRegType(FIX::CPRegType *arg1) {
    delete arg1;
}

swig_class SwigClassCashDistribAgentCode;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentCode";
  FIX::CashDistribAgentCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashDistribAgentCode *)new FIX::CashDistribAgentCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashDistribAgentCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashDistribAgentCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashDistribAgentCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashDistribAgentCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentCode";
  FIX::CashDistribAgentCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashDistribAgentCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashDistribAgentCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashDistribAgentCode *)new FIX::CashDistribAgentCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashDistribAgentCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashDistribAgentCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashDistribAgentCode.new", 
    "    CashDistribAgentCode.new()\n"
    "    CashDistribAgentCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentCode(FIX::CashDistribAgentCode *arg1) {
    delete arg1;
}

swig_class SwigClassExecPriceType;

SWIGINTERN VALUE
_wrap_new_ExecPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceType";
  FIX::ExecPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecPriceType *)new FIX::ExecPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceType";
  FIX::ExecPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExecPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExecPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExecPriceType *)new FIX::ExecPriceType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecPriceType.new", 
    "    ExecPriceType.new()\n"
    "    ExecPriceType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecPriceType(FIX::ExecPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassLegAllocID;

SWIGINTERN VALUE
_wrap_new_LegAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegAllocID";
  FIX::LegAllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegAllocID *)new FIX::LegAllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegAllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegAllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegAllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegAllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocID";
  FIX::LegAllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegAllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegAllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegAllocID *)new FIX::LegAllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegAllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegAllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegAllocID.new", 
    "    LegAllocID.new()\n"
    "    LegAllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocID(FIX::LegAllocID *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryTime;

SWIGINTERN VALUE
_wrap_new_MDEntryTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryTime";
  FIX::MDEntryTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryTime *)new FIX::MDEntryTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryTime";
  FIX::MDEntryTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMEONLY const &","FIX::MDEntryTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMEONLY const &","FIX::MDEntryTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  result = (FIX::MDEntryTime *)new FIX::MDEntryTime((FIX::UTCTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryTime.new", 
    "    MDEntryTime.new()\n"
    "    MDEntryTime.new(FIX::UTCTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryTime(FIX::MDEntryTime *arg1) {
    delete arg1;
}

swig_class SwigClassTotalNumSecurities;

SWIGINTERN VALUE
_wrap_new_TotalNumSecurities__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurities";
  FIX::TotalNumSecurities *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalNumSecurities *)new FIX::TotalNumSecurities();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalNumSecurities_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalNumSecurities_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalNumSecurities);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalNumSecurities__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurities";
  FIX::TotalNumSecurities *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotalNumSecurities", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotalNumSecurities", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotalNumSecurities *)new FIX::TotalNumSecurities((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalNumSecurities(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalNumSecurities__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNumSecurities__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalNumSecurities.new", 
    "    TotalNumSecurities.new()\n"
    "    TotalNumSecurities.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNumSecurities(FIX::TotalNumSecurities *arg1) {
    delete arg1;
}

swig_class SwigClassAllocSettlInstType;

SWIGINTERN VALUE
_wrap_new_AllocSettlInstType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlInstType";
  FIX::AllocSettlInstType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocSettlInstType *)new FIX::AllocSettlInstType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocSettlInstType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocSettlInstType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocSettlInstType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocSettlInstType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlInstType";
  FIX::AllocSettlInstType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocSettlInstType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocSettlInstType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocSettlInstType *)new FIX::AllocSettlInstType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocSettlInstType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocSettlInstType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocSettlInstType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocSettlInstType.new", 
    "    AllocSettlInstType.new()\n"
    "    AllocSettlInstType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocSettlInstType(FIX::AllocSettlInstType *arg1) {
    delete arg1;
}

swig_class SwigClassTargetPartyID;

SWIGINTERN VALUE
_wrap_new_TargetPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyID";
  FIX::TargetPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetPartyID *)new FIX::TargetPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyID";
  FIX::TargetPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TargetPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TargetPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TargetPartyID *)new FIX::TargetPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetPartyID.new", 
    "    TargetPartyID.new()\n"
    "    TargetPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetPartyID(FIX::TargetPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeCurrency";
  FIX::DerivativeStrikeCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeStrikeCurrency *)new FIX::DerivativeStrikeCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeStrikeCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeStrikeCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeStrikeCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeCurrency";
  FIX::DerivativeStrikeCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::DerivativeStrikeCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::DerivativeStrikeCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::DerivativeStrikeCurrency *)new FIX::DerivativeStrikeCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeStrikeCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeStrikeCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikeCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeStrikeCurrency.new", 
    "    DerivativeStrikeCurrency.new()\n"
    "    DerivativeStrikeCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikeCurrency(FIX::DerivativeStrikeCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassStatsType;

SWIGINTERN VALUE
_wrap_new_StatsType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StatsType";
  FIX::StatsType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StatsType *)new FIX::StatsType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StatsType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StatsType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StatsType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StatsType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatsType";
  FIX::StatsType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StatsType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StatsType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StatsType *)new FIX::StatsType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StatsType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StatsType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StatsType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StatsType.new", 
    "    StatsType.new()\n"
    "    StatsType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StatsType(FIX::StatsType *arg1) {
    delete arg1;
}

swig_class SwigClassApplExtID;

SWIGINTERN VALUE
_wrap_new_ApplExtID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplExtID";
  FIX::ApplExtID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplExtID *)new FIX::ApplExtID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplExtID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplExtID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplExtID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplExtID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplExtID";
  FIX::ApplExtID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplExtID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplExtID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplExtID *)new FIX::ApplExtID((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplExtID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplExtID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplExtID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplExtID.new", 
    "    ApplExtID.new()\n"
    "    ApplExtID.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplExtID(FIX::ApplExtID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlementCycleNo;

SWIGINTERN VALUE
_wrap_new_SettlementCycleNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlementCycleNo";
  FIX::SettlementCycleNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlementCycleNo *)new FIX::SettlementCycleNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlementCycleNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlementCycleNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlementCycleNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlementCycleNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlementCycleNo";
  FIX::SettlementCycleNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlementCycleNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlementCycleNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlementCycleNo *)new FIX::SettlementCycleNo((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlementCycleNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlementCycleNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlementCycleNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlementCycleNo.new", 
    "    SettlementCycleNo.new()\n"
    "    SettlementCycleNo.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlementCycleNo(FIX::SettlementCycleNo *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_UnderlyingStrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikeCurrency";
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingStrikeCurrency *)new FIX::UnderlyingStrikeCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingStrikeCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingStrikeCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingStrikeCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingStrikeCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikeCurrency";
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::UnderlyingStrikeCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::UnderlyingStrikeCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::UnderlyingStrikeCurrency *)new FIX::UnderlyingStrikeCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingStrikeCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingStrikeCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStrikeCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingStrikeCurrency.new", 
    "    UnderlyingStrikeCurrency.new()\n"
    "    UnderlyingStrikeCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStrikeCurrency(FIX::UnderlyingStrikeCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesMode;

SWIGINTERN VALUE
_wrap_new_TradSesMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesMode";
  FIX::TradSesMode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesMode *)new FIX::TradSesMode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesMode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesMode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesMode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesMode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesMode";
  FIX::TradSesMode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradSesMode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradSesMode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradSesMode *)new FIX::TradSesMode((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesMode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesMode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesMode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesMode.new", 
    "    TradSesMode.new()\n"
    "    TradSesMode.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesMode(FIX::TradSesMode *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstSource;

SWIGINTERN VALUE
_wrap_new_SettlInstSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstSource";
  FIX::SettlInstSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstSource *)new FIX::SettlInstSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstSource";
  FIX::SettlInstSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlInstSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlInstSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlInstSource *)new FIX::SettlInstSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstSource.new", 
    "    SettlInstSource.new()\n"
    "    SettlInstSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstSource(FIX::SettlInstSource *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityDesc";
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityDesc *)new FIX::UnderlyingLegSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityDesc";
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityDesc *)new FIX::UnderlyingLegSecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityDesc.new", 
    "    UnderlyingLegSecurityDesc.new()\n"
    "    UnderlyingLegSecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityDesc(FIX::UnderlyingLegSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassNoDerivativeInstrumentParties;

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrumentParties__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentParties";
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDerivativeInstrumentParties *)new FIX::NoDerivativeInstrumentParties();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDerivativeInstrumentParties_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDerivativeInstrumentParties_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDerivativeInstrumentParties);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrumentParties__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentParties";
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDerivativeInstrumentParties", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDerivativeInstrumentParties", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDerivativeInstrumentParties *)new FIX::NoDerivativeInstrumentParties((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDerivativeInstrumentParties(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDerivativeInstrumentParties__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeInstrumentParties__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDerivativeInstrumentParties.new", 
    "    NoDerivativeInstrumentParties.new()\n"
    "    NoDerivativeInstrumentParties.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeInstrumentParties(FIX::NoDerivativeInstrumentParties *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEventTime;

SWIGINTERN VALUE
_wrap_new_DerivativeEventTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  FIX::DerivativeEventTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DerivativeEventTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  FIX::DerivativeEventTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::DerivativeEventTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DerivativeEventTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  FIX::DerivativeEventTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::DerivativeEventTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::DerivativeEventTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEventTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEventTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEventTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEventTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  FIX::DerivativeEventTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::DerivativeEventTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::DerivativeEventTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::DerivativeEventTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEventTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEventTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DerivativeEventTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DerivativeEventTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "DerivativeEventTime.new", 
    "    DerivativeEventTime.new()\n"
    "    DerivativeEventTime.new(bool showMilliseconds)\n"
    "    DerivativeEventTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    DerivativeEventTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventTime(FIX::DerivativeEventTime *arg1) {
    delete arg1;
}

swig_class SwigClassTickIncrement;

SWIGINTERN VALUE
_wrap_new_TickIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TickIncrement";
  FIX::TickIncrement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TickIncrement *)new FIX::TickIncrement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TickIncrement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TickIncrement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TickIncrement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TickIncrement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickIncrement";
  FIX::TickIncrement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::TickIncrement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::TickIncrement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::TickIncrement *)new FIX::TickIncrement((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TickIncrement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TickIncrement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TickIncrement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TickIncrement.new", 
    "    TickIncrement.new()\n"
    "    TickIncrement.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TickIncrement(FIX::TickIncrement *arg1) {
    delete arg1;
}

swig_class SwigClassUndlyInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyID";
  FIX::UndlyInstrumentPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UndlyInstrumentPartyID *)new FIX::UndlyInstrumentPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UndlyInstrumentPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UndlyInstrumentPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UndlyInstrumentPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyID";
  FIX::UndlyInstrumentPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UndlyInstrumentPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UndlyInstrumentPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UndlyInstrumentPartyID *)new FIX::UndlyInstrumentPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UndlyInstrumentPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UndlyInstrumentPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UndlyInstrumentPartyID.new", 
    "    UndlyInstrumentPartyID.new()\n"
    "    UndlyInstrumentPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartyID(FIX::UndlyInstrumentPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassNoUndlyInstrumentParties;

SWIGINTERN VALUE
_wrap_new_NoUndlyInstrumentParties__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentParties";
  FIX::NoUndlyInstrumentParties *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUndlyInstrumentParties *)new FIX::NoUndlyInstrumentParties();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUndlyInstrumentParties_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUndlyInstrumentParties_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUndlyInstrumentParties);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUndlyInstrumentParties__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentParties";
  FIX::NoUndlyInstrumentParties *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUndlyInstrumentParties", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUndlyInstrumentParties", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUndlyInstrumentParties *)new FIX::NoUndlyInstrumentParties((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUndlyInstrumentParties(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUndlyInstrumentParties__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUndlyInstrumentParties__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUndlyInstrumentParties.new", 
    "    NoUndlyInstrumentParties.new()\n"
    "    NoUndlyInstrumentParties.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUndlyInstrumentParties(FIX::NoUndlyInstrumentParties *arg1) {
    delete arg1;
}

swig_class SwigClassExpType;

SWIGINTERN VALUE
_wrap_new_ExpType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExpType";
  FIX::ExpType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExpType *)new FIX::ExpType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExpType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExpType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExpType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExpType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpType";
  FIX::ExpType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ExpType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ExpType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ExpType *)new FIX::ExpType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExpType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExpType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExpType.new", 
    "    ExpType.new()\n"
    "    ExpType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpType(FIX::ExpType *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryClOrdID;

SWIGINTERN VALUE
_wrap_new_SecondaryClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryClOrdID";
  FIX::SecondaryClOrdID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryClOrdID *)new FIX::SecondaryClOrdID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryClOrdID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryClOrdID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryClOrdID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryClOrdID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryClOrdID";
  FIX::SecondaryClOrdID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryClOrdID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryClOrdID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryClOrdID *)new FIX::SecondaryClOrdID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryClOrdID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryClOrdID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryClOrdID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryClOrdID.new", 
    "    SecondaryClOrdID.new()\n"
    "    SecondaryClOrdID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryClOrdID(FIX::SecondaryClOrdID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstTransType;

SWIGINTERN VALUE
_wrap_new_SettlInstTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstTransType";
  FIX::SettlInstTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstTransType *)new FIX::SettlInstTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstTransType";
  FIX::SettlInstTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlInstTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlInstTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlInstTransType *)new FIX::SettlInstTransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstTransType.new", 
    "    SettlInstTransType.new()\n"
    "    SettlInstTransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstTransType(FIX::SettlInstTransType *arg1) {
    delete arg1;
}

swig_class SwigClassSideComplianceID;

SWIGINTERN VALUE
_wrap_new_SideComplianceID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideComplianceID";
  FIX::SideComplianceID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideComplianceID *)new FIX::SideComplianceID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideComplianceID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideComplianceID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideComplianceID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideComplianceID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideComplianceID";
  FIX::SideComplianceID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SideComplianceID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SideComplianceID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SideComplianceID *)new FIX::SideComplianceID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideComplianceID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideComplianceID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideComplianceID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideComplianceID.new", 
    "    SideComplianceID.new()\n"
    "    SideComplianceID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideComplianceID(FIX::SideComplianceID *arg1) {
    delete arg1;
}

swig_class SwigClassTradeRequestResult;

SWIGINTERN VALUE
_wrap_new_TradeRequestResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestResult";
  FIX::TradeRequestResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeRequestResult *)new FIX::TradeRequestResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeRequestResult_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeRequestResult_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeRequestResult);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeRequestResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestResult";
  FIX::TradeRequestResult *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeRequestResult", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeRequestResult", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeRequestResult *)new FIX::TradeRequestResult((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeRequestResult(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeRequestResult__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestResult__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeRequestResult.new", 
    "    TradeRequestResult.new()\n"
    "    TradeRequestResult.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestResult(FIX::TradeRequestResult *arg1) {
    delete arg1;
}

swig_class SwigClassOrigPosReqRefID;

SWIGINTERN VALUE
_wrap_new_OrigPosReqRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigPosReqRefID";
  FIX::OrigPosReqRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigPosReqRefID *)new FIX::OrigPosReqRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigPosReqRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigPosReqRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigPosReqRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigPosReqRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigPosReqRefID";
  FIX::OrigPosReqRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrigPosReqRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrigPosReqRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrigPosReqRefID *)new FIX::OrigPosReqRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigPosReqRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigPosReqRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigPosReqRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigPosReqRefID.new", 
    "    OrigPosReqRefID.new()\n"
    "    OrigPosReqRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigPosReqRefID(FIX::OrigPosReqRefID *arg1) {
    delete arg1;
}

swig_class SwigClassOrigCrossID;

SWIGINTERN VALUE
_wrap_new_OrigCrossID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigCrossID";
  FIX::OrigCrossID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigCrossID *)new FIX::OrigCrossID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigCrossID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigCrossID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigCrossID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigCrossID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigCrossID";
  FIX::OrigCrossID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrigCrossID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrigCrossID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrigCrossID *)new FIX::OrigCrossID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigCrossID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigCrossID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigCrossID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigCrossID.new", 
    "    OrigCrossID.new()\n"
    "    OrigCrossID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigCrossID(FIX::OrigCrossID *arg1) {
    delete arg1;
}

swig_class SwigClassTradeInputSource;

SWIGINTERN VALUE
_wrap_new_TradeInputSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeInputSource";
  FIX::TradeInputSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeInputSource *)new FIX::TradeInputSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeInputSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeInputSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeInputSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeInputSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeInputSource";
  FIX::TradeInputSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradeInputSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradeInputSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradeInputSource *)new FIX::TradeInputSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeInputSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeInputSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeInputSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeInputSource.new", 
    "    TradeInputSource.new()\n"
    "    TradeInputSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeInputSource(FIX::TradeInputSource *arg1) {
    delete arg1;
}

swig_class SwigClassOrderQty2;

SWIGINTERN VALUE
_wrap_new_OrderQty2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderQty2";
  FIX::OrderQty2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderQty2 *)new FIX::OrderQty2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderQty2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderQty2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderQty2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderQty2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderQty2";
  FIX::OrderQty2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::OrderQty2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::OrderQty2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::OrderQty2 *)new FIX::OrderQty2((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderQty2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderQty2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderQty2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderQty2.new", 
    "    OrderQty2.new()\n"
    "    OrderQty2.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderQty2(FIX::OrderQty2 *arg1) {
    delete arg1;
}

swig_class SwigClassTestMessageIndicator;

SWIGINTERN VALUE
_wrap_new_TestMessageIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TestMessageIndicator";
  FIX::TestMessageIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TestMessageIndicator *)new FIX::TestMessageIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TestMessageIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TestMessageIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TestMessageIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TestMessageIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TestMessageIndicator";
  FIX::TestMessageIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::TestMessageIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::TestMessageIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::TestMessageIndicator *)new FIX::TestMessageIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TestMessageIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TestMessageIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TestMessageIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TestMessageIndicator.new", 
    "    TestMessageIndicator.new()\n"
    "    TestMessageIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TestMessageIndicator(FIX::TestMessageIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEventDate;

SWIGINTERN VALUE
_wrap_new_DerivativeEventDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventDate";
  FIX::DerivativeEventDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEventDate *)new FIX::DerivativeEventDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEventDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEventDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEventDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEventDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventDate";
  FIX::DerivativeEventDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::DerivativeEventDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::DerivativeEventDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::DerivativeEventDate *)new FIX::DerivativeEventDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEventDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEventDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEventDate.new", 
    "    DerivativeEventDate.new()\n"
    "    DerivativeEventDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventDate(FIX::DerivativeEventDate *arg1) {
    delete arg1;
}

swig_class SwigClassSideGrossTradeAmt;

SWIGINTERN VALUE
_wrap_new_SideGrossTradeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideGrossTradeAmt";
  FIX::SideGrossTradeAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideGrossTradeAmt *)new FIX::SideGrossTradeAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideGrossTradeAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideGrossTradeAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideGrossTradeAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideGrossTradeAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideGrossTradeAmt";
  FIX::SideGrossTradeAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::SideGrossTradeAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::SideGrossTradeAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::SideGrossTradeAmt *)new FIX::SideGrossTradeAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideGrossTradeAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideGrossTradeAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideGrossTradeAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideGrossTradeAmt.new", 
    "    SideGrossTradeAmt.new()\n"
    "    SideGrossTradeAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideGrossTradeAmt(FIX::SideGrossTradeAmt *arg1) {
    delete arg1;
}

swig_class SwigClassPeggedPrice;

SWIGINTERN VALUE
_wrap_new_PeggedPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PeggedPrice";
  FIX::PeggedPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PeggedPrice *)new FIX::PeggedPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PeggedPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PeggedPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PeggedPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PeggedPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PeggedPrice";
  FIX::PeggedPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::PeggedPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::PeggedPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::PeggedPrice *)new FIX::PeggedPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PeggedPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PeggedPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PeggedPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PeggedPrice.new", 
    "    PeggedPrice.new()\n"
    "    PeggedPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PeggedPrice(FIX::PeggedPrice *arg1) {
    delete arg1;
}

swig_class SwigClassExpirationCycle;

SWIGINTERN VALUE
_wrap_new_ExpirationCycle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExpirationCycle";
  FIX::ExpirationCycle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExpirationCycle *)new FIX::ExpirationCycle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExpirationCycle_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExpirationCycle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExpirationCycle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExpirationCycle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpirationCycle";
  FIX::ExpirationCycle *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ExpirationCycle", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ExpirationCycle", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ExpirationCycle *)new FIX::ExpirationCycle((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExpirationCycle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExpirationCycle__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpirationCycle__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExpirationCycle.new", 
    "    ExpirationCycle.new()\n"
    "    ExpirationCycle.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpirationCycle(FIX::ExpirationCycle *arg1) {
    delete arg1;
}

swig_class SwigClassAllocCancReplaceReason;

SWIGINTERN VALUE
_wrap_new_AllocCancReplaceReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocCancReplaceReason";
  FIX::AllocCancReplaceReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocCancReplaceReason *)new FIX::AllocCancReplaceReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocCancReplaceReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocCancReplaceReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocCancReplaceReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocCancReplaceReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocCancReplaceReason";
  FIX::AllocCancReplaceReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocCancReplaceReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocCancReplaceReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocCancReplaceReason *)new FIX::AllocCancReplaceReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocCancReplaceReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocCancReplaceReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocCancReplaceReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocCancReplaceReason.new", 
    "    AllocCancReplaceReason.new()\n"
    "    AllocCancReplaceReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocCancReplaceReason(FIX::AllocCancReplaceReason *arg1) {
    delete arg1;
}

swig_class SwigClassCxlRejReason;

SWIGINTERN VALUE
_wrap_new_CxlRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CxlRejReason";
  FIX::CxlRejReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CxlRejReason *)new FIX::CxlRejReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CxlRejReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CxlRejReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CxlRejReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CxlRejReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlRejReason";
  FIX::CxlRejReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CxlRejReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CxlRejReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CxlRejReason *)new FIX::CxlRejReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CxlRejReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CxlRejReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlRejReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CxlRejReason.new", 
    "    CxlRejReason.new()\n"
    "    CxlRejReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlRejReason(FIX::CxlRejReason *arg1) {
    delete arg1;
}

swig_class SwigClassBeginString;

SWIGINTERN VALUE
_wrap_new_BeginString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BeginString";
  FIX::BeginString *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BeginString *)new FIX::BeginString();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BeginString_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BeginString_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BeginString);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BeginString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BeginString";
  FIX::BeginString *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BeginString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BeginString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BeginString *)new FIX::BeginString((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BeginString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BeginString__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BeginString__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BeginString.new", 
    "    BeginString.new()\n"
    "    BeginString.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BeginString(FIX::BeginString *arg1) {
    delete arg1;
}

swig_class SwigClassDeliverToSubID;

SWIGINTERN VALUE
_wrap_new_DeliverToSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeliverToSubID";
  FIX::DeliverToSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeliverToSubID *)new FIX::DeliverToSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeliverToSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeliverToSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeliverToSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeliverToSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToSubID";
  FIX::DeliverToSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DeliverToSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DeliverToSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DeliverToSubID *)new FIX::DeliverToSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeliverToSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeliverToSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliverToSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeliverToSubID.new", 
    "    DeliverToSubID.new()\n"
    "    DeliverToSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliverToSubID(FIX::DeliverToSubID *arg1) {
    delete arg1;
}

swig_class SwigClassLegPriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_LegPriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasureQty";
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPriceUnitOfMeasureQty *)new FIX::LegPriceUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPriceUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPriceUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPriceUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasureQty";
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegPriceUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegPriceUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegPriceUnitOfMeasureQty *)new FIX::LegPriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPriceUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPriceUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPriceUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPriceUnitOfMeasureQty.new", 
    "    LegPriceUnitOfMeasureQty.new()\n"
    "    LegPriceUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPriceUnitOfMeasureQty(FIX::LegPriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassNoCollInquiryQualifier;

SWIGINTERN VALUE
_wrap_new_NoCollInquiryQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoCollInquiryQualifier";
  FIX::NoCollInquiryQualifier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoCollInquiryQualifier *)new FIX::NoCollInquiryQualifier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoCollInquiryQualifier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoCollInquiryQualifier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoCollInquiryQualifier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoCollInquiryQualifier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCollInquiryQualifier";
  FIX::NoCollInquiryQualifier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoCollInquiryQualifier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoCollInquiryQualifier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoCollInquiryQualifier *)new FIX::NoCollInquiryQualifier((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoCollInquiryQualifier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoCollInquiryQualifier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoCollInquiryQualifier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoCollInquiryQualifier.new", 
    "    NoCollInquiryQualifier.new()\n"
    "    NoCollInquiryQualifier.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoCollInquiryQualifier(FIX::NoCollInquiryQualifier *arg1) {
    delete arg1;
}

swig_class SwigClassOfferPx;

SWIGINTERN VALUE
_wrap_new_OfferPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferPx";
  FIX::OfferPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferPx *)new FIX::OfferPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferPx";
  FIX::OfferPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::OfferPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::OfferPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::OfferPx *)new FIX::OfferPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferPx.new", 
    "    OfferPx.new()\n"
    "    OfferPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferPx(FIX::OfferPx *arg1) {
    delete arg1;
}

swig_class SwigClassTotalVolumeTradedDate;

SWIGINTERN VALUE
_wrap_new_TotalVolumeTradedDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedDate";
  FIX::TotalVolumeTradedDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalVolumeTradedDate *)new FIX::TotalVolumeTradedDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalVolumeTradedDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalVolumeTradedDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalVolumeTradedDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalVolumeTradedDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::UTCDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedDate";
  FIX::TotalVolumeTradedDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCDATE const &","FIX::TotalVolumeTradedDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCDATE const &","FIX::TotalVolumeTradedDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCDATE * >(argp1);
  result = (FIX::TotalVolumeTradedDate *)new FIX::TotalVolumeTradedDate((FIX::UTCDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalVolumeTradedDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalVolumeTradedDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTradedDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalVolumeTradedDate.new", 
    "    TotalVolumeTradedDate.new()\n"
    "    TotalVolumeTradedDate.new(FIX::UTCDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalVolumeTradedDate(FIX::TotalVolumeTradedDate *arg1) {
    delete arg1;
}

swig_class SwigClassNoContAmts;

SWIGINTERN VALUE
_wrap_new_NoContAmts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoContAmts";
  FIX::NoContAmts *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoContAmts *)new FIX::NoContAmts();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoContAmts_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoContAmts_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoContAmts);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoContAmts__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContAmts";
  FIX::NoContAmts *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoContAmts", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoContAmts", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoContAmts *)new FIX::NoContAmts((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoContAmts(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoContAmts__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoContAmts__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoContAmts.new", 
    "    NoContAmts.new()\n"
    "    NoContAmts.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoContAmts(FIX::NoContAmts *arg1) {
    delete arg1;
}

swig_class SwigClassMinOfferSize;

SWIGINTERN VALUE
_wrap_new_MinOfferSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinOfferSize";
  FIX::MinOfferSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinOfferSize *)new FIX::MinOfferSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinOfferSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinOfferSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinOfferSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinOfferSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinOfferSize";
  FIX::MinOfferSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MinOfferSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MinOfferSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MinOfferSize *)new FIX::MinOfferSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinOfferSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinOfferSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinOfferSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinOfferSize.new", 
    "    MinOfferSize.new()\n"
    "    MinOfferSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinOfferSize(FIX::MinOfferSize *arg1) {
    delete arg1;
}

swig_class SwigClassAvgParPx;

SWIGINTERN VALUE
_wrap_new_AvgParPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AvgParPx";
  FIX::AvgParPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AvgParPx *)new FIX::AvgParPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AvgParPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AvgParPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AvgParPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AvgParPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgParPx";
  FIX::AvgParPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::AvgParPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::AvgParPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::AvgParPx *)new FIX::AvgParPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AvgParPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AvgParPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgParPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AvgParPx.new", 
    "    AvgParPx.new()\n"
    "    AvgParPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgParPx(FIX::AvgParPx *arg1) {
    delete arg1;
}

swig_class SwigClassLegFactor;

SWIGINTERN VALUE
_wrap_new_LegFactor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegFactor";
  FIX::LegFactor *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegFactor *)new FIX::LegFactor();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegFactor_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegFactor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegFactor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegFactor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFactor";
  FIX::LegFactor *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::LegFactor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::LegFactor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::LegFactor *)new FIX::LegFactor((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegFactor(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegFactor__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegFactor__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegFactor.new", 
    "    LegFactor.new()\n"
    "    LegFactor.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegFactor(FIX::LegFactor *arg1) {
    delete arg1;
}

swig_class SwigClassRespondentType;

SWIGINTERN VALUE
_wrap_new_RespondentType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RespondentType";
  FIX::RespondentType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RespondentType *)new FIX::RespondentType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RespondentType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RespondentType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RespondentType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RespondentType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RespondentType";
  FIX::RespondentType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RespondentType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RespondentType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RespondentType *)new FIX::RespondentType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RespondentType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RespondentType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RespondentType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RespondentType.new", 
    "    RespondentType.new()\n"
    "    RespondentType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RespondentType(FIX::RespondentType *arg1) {
    delete arg1;
}

swig_class SwigClassDisplayLowQty;

SWIGINTERN VALUE
_wrap_new_DisplayLowQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DisplayLowQty";
  FIX::DisplayLowQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DisplayLowQty *)new FIX::DisplayLowQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DisplayLowQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DisplayLowQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DisplayLowQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DisplayLowQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayLowQty";
  FIX::DisplayLowQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DisplayLowQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DisplayLowQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DisplayLowQty *)new FIX::DisplayLowQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DisplayLowQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DisplayLowQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayLowQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DisplayLowQty.new", 
    "    DisplayLowQty.new()\n"
    "    DisplayLowQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayLowQty(FIX::DisplayLowQty *arg1) {
    delete arg1;
}

swig_class SwigClassDKReason;

SWIGINTERN VALUE
_wrap_new_DKReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DKReason";
  FIX::DKReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DKReason *)new FIX::DKReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DKReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DKReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DKReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DKReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DKReason";
  FIX::DKReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DKReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DKReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DKReason *)new FIX::DKReason((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DKReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DKReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DKReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DKReason.new", 
    "    DKReason.new()\n"
    "    DKReason.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DKReason(FIX::DKReason *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkPrice;

SWIGINTERN VALUE
_wrap_new_BenchmarkPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPrice";
  FIX::BenchmarkPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkPrice *)new FIX::BenchmarkPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPrice";
  FIX::BenchmarkPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::BenchmarkPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::BenchmarkPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::BenchmarkPrice *)new FIX::BenchmarkPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkPrice.new", 
    "    BenchmarkPrice.new()\n"
    "    BenchmarkPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkPrice(FIX::BenchmarkPrice *arg1) {
    delete arg1;
}

swig_class SwigClassListID;

SWIGINTERN VALUE
_wrap_new_ListID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListID";
  FIX::ListID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListID *)new FIX::ListID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListID";
  FIX::ListID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ListID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ListID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ListID *)new FIX::ListID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListID.new", 
    "    ListID.new()\n"
    "    ListID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListID(FIX::ListID *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_LegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltID";
  FIX::LegSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityAltID *)new FIX::LegSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltID";
  FIX::LegSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecurityAltID *)new FIX::LegSecurityAltID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityAltID.new", 
    "    LegSecurityAltID.new()\n"
    "    LegSecurityAltID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityAltID(FIX::LegSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassPositionEffect;

SWIGINTERN VALUE
_wrap_new_PositionEffect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PositionEffect";
  FIX::PositionEffect *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PositionEffect *)new FIX::PositionEffect();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PositionEffect_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PositionEffect_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PositionEffect);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PositionEffect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionEffect";
  FIX::PositionEffect *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::PositionEffect", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::PositionEffect", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::PositionEffect *)new FIX::PositionEffect((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PositionEffect(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PositionEffect__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionEffect__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PositionEffect.new", 
    "    PositionEffect.new()\n"
    "    PositionEffect.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PositionEffect(FIX::PositionEffect *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerAction;

SWIGINTERN VALUE
_wrap_new_TriggerAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerAction";
  FIX::TriggerAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerAction *)new FIX::TriggerAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerAction";
  FIX::TriggerAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TriggerAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TriggerAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TriggerAction *)new FIX::TriggerAction((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerAction.new", 
    "    TriggerAction.new()\n"
    "    TriggerAction.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerAction(FIX::TriggerAction *arg1) {
    delete arg1;
}

swig_class SwigClassRefOrderID;

SWIGINTERN VALUE
_wrap_new_RefOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefOrderID";
  FIX::RefOrderID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefOrderID *)new FIX::RefOrderID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefOrderID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefOrderID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefOrderID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefOrderID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrderID";
  FIX::RefOrderID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefOrderID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefOrderID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefOrderID *)new FIX::RefOrderID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefOrderID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefOrderID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefOrderID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefOrderID.new", 
    "    RefOrderID.new()\n"
    "    RefOrderID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefOrderID(FIX::RefOrderID *arg1) {
    delete arg1;
}

swig_class SwigClassClearingInstruction;

SWIGINTERN VALUE
_wrap_new_ClearingInstruction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClearingInstruction";
  FIX::ClearingInstruction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClearingInstruction *)new FIX::ClearingInstruction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClearingInstruction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClearingInstruction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClearingInstruction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClearingInstruction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingInstruction";
  FIX::ClearingInstruction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ClearingInstruction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ClearingInstruction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ClearingInstruction *)new FIX::ClearingInstruction((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClearingInstruction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClearingInstruction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingInstruction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClearingInstruction.new", 
    "    ClearingInstruction.new()\n"
    "    ClearingInstruction.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingInstruction(FIX::ClearingInstruction *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstCode;

SWIGINTERN VALUE
_wrap_new_SettlInstCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstCode";
  FIX::SettlInstCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstCode *)new FIX::SettlInstCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstCode";
  FIX::SettlInstCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlInstCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlInstCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlInstCode *)new FIX::SettlInstCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstCode.new", 
    "    SettlInstCode.new()\n"
    "    SettlInstCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstCode(FIX::SettlInstCode *arg1) {
    delete arg1;
}

swig_class SwigClassNumDaysInterest;

SWIGINTERN VALUE
_wrap_new_NumDaysInterest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NumDaysInterest";
  FIX::NumDaysInterest *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NumDaysInterest *)new FIX::NumDaysInterest();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NumDaysInterest_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NumDaysInterest_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NumDaysInterest);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NumDaysInterest__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumDaysInterest";
  FIX::NumDaysInterest *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NumDaysInterest", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NumDaysInterest", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NumDaysInterest *)new FIX::NumDaysInterest((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NumDaysInterest(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NumDaysInterest__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumDaysInterest__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NumDaysInterest.new", 
    "    NumDaysInterest.new()\n"
    "    NumDaysInterest.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NumDaysInterest(FIX::NumDaysInterest *arg1) {
    delete arg1;
}

swig_class SwigClassOpenCloseSettlFlag;

SWIGINTERN VALUE
_wrap_new_OpenCloseSettlFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettlFlag";
  FIX::OpenCloseSettlFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OpenCloseSettlFlag *)new FIX::OpenCloseSettlFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OpenCloseSettlFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OpenCloseSettlFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OpenCloseSettlFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettlFlag";
  FIX::OpenCloseSettlFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::OpenCloseSettlFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::OpenCloseSettlFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::OpenCloseSettlFlag *)new FIX::OpenCloseSettlFlag((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OpenCloseSettlFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OpenCloseSettlFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenCloseSettlFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OpenCloseSettlFlag.new", 
    "    OpenCloseSettlFlag.new()\n"
    "    OpenCloseSettlFlag.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenCloseSettlFlag(FIX::OpenCloseSettlFlag *arg1) {
    delete arg1;
}

swig_class SwigClassNoComplexEventDates;

SWIGINTERN VALUE
_wrap_new_NoComplexEventDates__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventDates";
  FIX::NoComplexEventDates *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoComplexEventDates *)new FIX::NoComplexEventDates();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoComplexEventDates_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoComplexEventDates_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoComplexEventDates);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoComplexEventDates__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventDates";
  FIX::NoComplexEventDates *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoComplexEventDates", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoComplexEventDates", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoComplexEventDates *)new FIX::NoComplexEventDates((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoComplexEventDates(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoComplexEventDates__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoComplexEventDates__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoComplexEventDates.new", 
    "    NoComplexEventDates.new()\n"
    "    NoComplexEventDates.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoComplexEventDates(FIX::NoComplexEventDates *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEncodedIssuerLen;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuerLen";
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEncodedIssuerLen *)new FIX::DerivativeEncodedIssuerLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEncodedIssuerLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEncodedIssuerLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedIssuerLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuerLen";
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::DerivativeEncodedIssuerLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::DerivativeEncodedIssuerLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::DerivativeEncodedIssuerLen *)new FIX::DerivativeEncodedIssuerLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEncodedIssuerLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEncodedIssuerLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedIssuerLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEncodedIssuerLen.new", 
    "    DerivativeEncodedIssuerLen.new()\n"
    "    DerivativeEncodedIssuerLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedIssuerLen(FIX::DerivativeEncodedIssuerLen *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeMultiplier;

SWIGINTERN VALUE
_wrap_new_StrikeMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeMultiplier";
  FIX::StrikeMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeMultiplier *)new FIX::StrikeMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeMultiplier";
  FIX::StrikeMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::StrikeMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::StrikeMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::StrikeMultiplier *)new FIX::StrikeMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikeMultiplier.new", 
    "    StrikeMultiplier.new()\n"
    "    StrikeMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeMultiplier(FIX::StrikeMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionMoveType;

SWIGINTERN VALUE
_wrap_new_DiscretionMoveType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionMoveType";
  FIX::DiscretionMoveType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionMoveType *)new FIX::DiscretionMoveType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionMoveType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionMoveType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionMoveType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionMoveType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionMoveType";
  FIX::DiscretionMoveType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DiscretionMoveType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DiscretionMoveType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DiscretionMoveType *)new FIX::DiscretionMoveType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionMoveType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionMoveType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionMoveType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionMoveType.new", 
    "    DiscretionMoveType.new()\n"
    "    DiscretionMoveType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionMoveType(FIX::DiscretionMoveType *arg1) {
    delete arg1;
}

swig_class SwigClassListNoOrds;

SWIGINTERN VALUE
_wrap_new_ListNoOrds__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListNoOrds";
  FIX::ListNoOrds *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListNoOrds *)new FIX::ListNoOrds();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListNoOrds_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListNoOrds_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListNoOrds);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListNoOrds__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListNoOrds";
  FIX::ListNoOrds *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ListNoOrds", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ListNoOrds", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ListNoOrds *)new FIX::ListNoOrds((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListNoOrds(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListNoOrds__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListNoOrds__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListNoOrds.new", 
    "    ListNoOrds.new()\n"
    "    ListNoOrds.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListNoOrds(FIX::ListNoOrds *arg1) {
    delete arg1;
}

swig_class SwigClassPegSymbol;

SWIGINTERN VALUE
_wrap_new_PegSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegSymbol";
  FIX::PegSymbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegSymbol *)new FIX::PegSymbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegSymbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegSymbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegSymbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSymbol";
  FIX::PegSymbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PegSymbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PegSymbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PegSymbol *)new FIX::PegSymbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegSymbol.new", 
    "    PegSymbol.new()\n"
    "    PegSymbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSymbol(FIX::PegSymbol *arg1) {
    delete arg1;
}

swig_class SwigClassDayAvgPx;

SWIGINTERN VALUE
_wrap_new_DayAvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DayAvgPx";
  FIX::DayAvgPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DayAvgPx *)new FIX::DayAvgPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DayAvgPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DayAvgPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DayAvgPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DayAvgPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayAvgPx";
  FIX::DayAvgPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::DayAvgPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::DayAvgPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::DayAvgPx *)new FIX::DayAvgPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DayAvgPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DayAvgPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayAvgPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DayAvgPx.new", 
    "    DayAvgPx.new()\n"
    "    DayAvgPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DayAvgPx(FIX::DayAvgPx *arg1) {
    delete arg1;
}

swig_class SwigClassHeadline;

SWIGINTERN VALUE
_wrap_new_Headline__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Headline";
  FIX::Headline *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Headline *)new FIX::Headline();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Headline_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Headline_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Headline);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Headline__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Headline";
  FIX::Headline *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Headline", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Headline", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Headline *)new FIX::Headline((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Headline(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Headline__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Headline__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Headline.new", 
    "    Headline.new()\n"
    "    Headline.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Headline(FIX::Headline *arg1) {
    delete arg1;
}

swig_class SwigClassNestedPartySubID;

SWIGINTERN VALUE
_wrap_new_NestedPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubID";
  FIX::NestedPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedPartySubID *)new FIX::NestedPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubID";
  FIX::NestedPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NestedPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NestedPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NestedPartySubID *)new FIX::NestedPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedPartySubID.new", 
    "    NestedPartySubID.new()\n"
    "    NestedPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartySubID(FIX::NestedPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassCardIssNo;

SWIGINTERN VALUE
_wrap_new_CardIssNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CardIssNo";
  FIX::CardIssNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CardIssNo *)new FIX::CardIssNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CardIssNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CardIssNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CardIssNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CardIssNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardIssNo";
  FIX::CardIssNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CardIssNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CardIssNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CardIssNo *)new FIX::CardIssNo((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CardIssNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CardIssNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardIssNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CardIssNo.new", 
    "    CardIssNo.new()\n"
    "    CardIssNo.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CardIssNo(FIX::CardIssNo *arg1) {
    delete arg1;
}

swig_class SwigClassOptAttribute;

SWIGINTERN VALUE
_wrap_new_OptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OptAttribute";
  FIX::OptAttribute *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OptAttribute *)new FIX::OptAttribute();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OptAttribute_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OptAttribute_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OptAttribute);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OptAttribute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptAttribute";
  FIX::OptAttribute *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OptAttribute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OptAttribute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OptAttribute *)new FIX::OptAttribute((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OptAttribute(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OptAttribute__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptAttribute__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OptAttribute.new", 
    "    OptAttribute.new()\n"
    "    OptAttribute.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OptAttribute(FIX::OptAttribute *arg1) {
    delete arg1;
}

swig_class SwigClassLastForwardPoints2;

SWIGINTERN VALUE
_wrap_new_LastForwardPoints2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints2";
  FIX::LastForwardPoints2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastForwardPoints2 *)new FIX::LastForwardPoints2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastForwardPoints2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastForwardPoints2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastForwardPoints2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastForwardPoints2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints2";
  FIX::LastForwardPoints2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::LastForwardPoints2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::LastForwardPoints2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::LastForwardPoints2 *)new FIX::LastForwardPoints2((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastForwardPoints2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastForwardPoints2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastForwardPoints2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastForwardPoints2.new", 
    "    LastForwardPoints2.new()\n"
    "    LastForwardPoints2.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastForwardPoints2(FIX::LastForwardPoints2 *arg1) {
    delete arg1;
}

swig_class SwigClassMDUpdateType;

SWIGINTERN VALUE
_wrap_new_MDUpdateType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateType";
  FIX::MDUpdateType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDUpdateType *)new FIX::MDUpdateType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDUpdateType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDUpdateType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDUpdateType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDUpdateType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateType";
  FIX::MDUpdateType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDUpdateType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDUpdateType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDUpdateType *)new FIX::MDUpdateType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDUpdateType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDUpdateType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDUpdateType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDUpdateType.new", 
    "    MDUpdateType.new()\n"
    "    MDUpdateType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDUpdateType(FIX::MDUpdateType *arg1) {
    delete arg1;
}

swig_class SwigClassTickDirection;

SWIGINTERN VALUE
_wrap_new_TickDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TickDirection";
  FIX::TickDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TickDirection *)new FIX::TickDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TickDirection_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TickDirection_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TickDirection);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TickDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickDirection";
  FIX::TickDirection *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TickDirection", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TickDirection", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TickDirection *)new FIX::TickDirection((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TickDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TickDirection__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TickDirection__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TickDirection.new", 
    "    TickDirection.new()\n"
    "    TickDirection.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TickDirection(FIX::TickDirection *arg1) {
    delete arg1;
}

swig_class SwigClassLegRedemptionDate;

SWIGINTERN VALUE
_wrap_new_LegRedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegRedemptionDate";
  FIX::LegRedemptionDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegRedemptionDate *)new FIX::LegRedemptionDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegRedemptionDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegRedemptionDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegRedemptionDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegRedemptionDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRedemptionDate";
  FIX::LegRedemptionDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegRedemptionDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegRedemptionDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegRedemptionDate *)new FIX::LegRedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegRedemptionDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegRedemptionDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRedemptionDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegRedemptionDate.new", 
    "    LegRedemptionDate.new()\n"
    "    LegRedemptionDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRedemptionDate(FIX::LegRedemptionDate *arg1) {
    delete arg1;
}

swig_class SwigClassStrikePrice;

SWIGINTERN VALUE
_wrap_new_StrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikePrice";
  FIX::StrikePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikePrice *)new FIX::StrikePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePrice";
  FIX::StrikePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::StrikePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::StrikePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::StrikePrice *)new FIX::StrikePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikePrice.new", 
    "    StrikePrice.new()\n"
    "    StrikePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePrice(FIX::StrikePrice *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedIssuer;

SWIGINTERN VALUE
_wrap_new_EncodedIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuer";
  FIX::EncodedIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedIssuer *)new FIX::EncodedIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuer";
  FIX::EncodedIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedIssuer *)new FIX::EncodedIssuer((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedIssuer.new", 
    "    EncodedIssuer.new()\n"
    "    EncodedIssuer.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedIssuer(FIX::EncodedIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassYieldType;

SWIGINTERN VALUE
_wrap_new_YieldType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::YieldType";
  FIX::YieldType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::YieldType *)new FIX::YieldType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_YieldType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_YieldType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__YieldType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_YieldType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldType";
  FIX::YieldType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::YieldType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::YieldType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::YieldType *)new FIX::YieldType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_YieldType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_YieldType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "YieldType.new", 
    "    YieldType.new()\n"
    "    YieldType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldType(FIX::YieldType *arg1) {
    delete arg1;
}

swig_class SwigClassTradingReferencePrice;

SWIGINTERN VALUE
_wrap_new_TradingReferencePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradingReferencePrice";
  FIX::TradingReferencePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradingReferencePrice *)new FIX::TradingReferencePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradingReferencePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradingReferencePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradingReferencePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradingReferencePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingReferencePrice";
  FIX::TradingReferencePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::TradingReferencePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::TradingReferencePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::TradingReferencePrice *)new FIX::TradingReferencePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradingReferencePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradingReferencePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingReferencePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradingReferencePrice.new", 
    "    TradingReferencePrice.new()\n"
    "    TradingReferencePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingReferencePrice(FIX::TradingReferencePrice *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntrySpotRate;

SWIGINTERN VALUE
_wrap_new_MDEntrySpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySpotRate";
  FIX::MDEntrySpotRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntrySpotRate *)new FIX::MDEntrySpotRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntrySpotRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntrySpotRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntrySpotRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntrySpotRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySpotRate";
  FIX::MDEntrySpotRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::MDEntrySpotRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::MDEntrySpotRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::MDEntrySpotRate *)new FIX::MDEntrySpotRate((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntrySpotRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntrySpotRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntrySpotRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntrySpotRate.new", 
    "    MDEntrySpotRate.new()\n"
    "    MDEntrySpotRate.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntrySpotRate(FIX::MDEntrySpotRate *arg1) {
    delete arg1;
}

swig_class SwigClassParticipationRate;

SWIGINTERN VALUE
_wrap_new_ParticipationRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ParticipationRate";
  FIX::ParticipationRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ParticipationRate *)new FIX::ParticipationRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ParticipationRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ParticipationRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ParticipationRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ParticipationRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ParticipationRate";
  FIX::ParticipationRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::ParticipationRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::ParticipationRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::ParticipationRate *)new FIX::ParticipationRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ParticipationRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ParticipationRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ParticipationRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ParticipationRate.new", 
    "    ParticipationRate.new()\n"
    "    ParticipationRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ParticipationRate(FIX::ParticipationRate *arg1) {
    delete arg1;
}

swig_class SwigClassPegScope;

SWIGINTERN VALUE
_wrap_new_PegScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegScope";
  FIX::PegScope *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegScope *)new FIX::PegScope();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegScope_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegScope_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegScope);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegScope__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegScope";
  FIX::PegScope *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PegScope", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PegScope", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PegScope *)new FIX::PegScope((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegScope(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegScope__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegScope__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegScope.new", 
    "    PegScope.new()\n"
    "    PegScope.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegScope(FIX::PegScope *arg1) {
    delete arg1;
}

swig_class SwigClassInterestAtMaturity;

SWIGINTERN VALUE
_wrap_new_InterestAtMaturity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InterestAtMaturity";
  FIX::InterestAtMaturity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InterestAtMaturity *)new FIX::InterestAtMaturity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InterestAtMaturity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InterestAtMaturity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InterestAtMaturity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InterestAtMaturity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InterestAtMaturity";
  FIX::InterestAtMaturity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::InterestAtMaturity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::InterestAtMaturity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::InterestAtMaturity *)new FIX::InterestAtMaturity((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InterestAtMaturity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InterestAtMaturity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InterestAtMaturity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InterestAtMaturity.new", 
    "    InterestAtMaturity.new()\n"
    "    InterestAtMaturity.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InterestAtMaturity(FIX::InterestAtMaturity *arg1) {
    delete arg1;
}

swig_class SwigClassLegIndividualAllocID;

SWIGINTERN VALUE
_wrap_new_LegIndividualAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegIndividualAllocID";
  FIX::LegIndividualAllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegIndividualAllocID *)new FIX::LegIndividualAllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegIndividualAllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegIndividualAllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegIndividualAllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegIndividualAllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIndividualAllocID";
  FIX::LegIndividualAllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegIndividualAllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegIndividualAllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegIndividualAllocID *)new FIX::LegIndividualAllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegIndividualAllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegIndividualAllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIndividualAllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegIndividualAllocID.new", 
    "    LegIndividualAllocID.new()\n"
    "    LegIndividualAllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIndividualAllocID(FIX::LegIndividualAllocID *arg1) {
    delete arg1;
}

swig_class SwigClassAllowableOneSidednessValue;

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessValue";
  FIX::AllowableOneSidednessValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllowableOneSidednessValue *)new FIX::AllowableOneSidednessValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllowableOneSidednessValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllowableOneSidednessValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllowableOneSidednessValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessValue";
  FIX::AllowableOneSidednessValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::AllowableOneSidednessValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::AllowableOneSidednessValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::AllowableOneSidednessValue *)new FIX::AllowableOneSidednessValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllowableOneSidednessValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllowableOneSidednessValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllowableOneSidednessValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllowableOneSidednessValue.new", 
    "    AllowableOneSidednessValue.new()\n"
    "    AllowableOneSidednessValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllowableOneSidednessValue(FIX::AllowableOneSidednessValue *arg1) {
    delete arg1;
}

swig_class SwigClassCashSettlAgentName;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentName";
  FIX::CashSettlAgentName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashSettlAgentName *)new FIX::CashSettlAgentName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashSettlAgentName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashSettlAgentName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashSettlAgentName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashSettlAgentName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentName";
  FIX::CashSettlAgentName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashSettlAgentName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashSettlAgentName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashSettlAgentName *)new FIX::CashSettlAgentName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashSettlAgentName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashSettlAgentName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashSettlAgentName.new", 
    "    CashSettlAgentName.new()\n"
    "    CashSettlAgentName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentName(FIX::CashSettlAgentName *arg1) {
    delete arg1;
}

swig_class SwigClassContraTradeQty;

SWIGINTERN VALUE
_wrap_new_ContraTradeQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeQty";
  FIX::ContraTradeQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContraTradeQty *)new FIX::ContraTradeQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContraTradeQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContraTradeQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContraTradeQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContraTradeQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeQty";
  FIX::ContraTradeQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::ContraTradeQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::ContraTradeQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::ContraTradeQty *)new FIX::ContraTradeQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContraTradeQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContraTradeQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraTradeQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContraTradeQty.new", 
    "    ContraTradeQty.new()\n"
    "    ContraTradeQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraTradeQty(FIX::ContraTradeQty *arg1) {
    delete arg1;
}

swig_class SwigClassLegMaturityTime;

SWIGINTERN VALUE
_wrap_new_LegMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityTime";
  FIX::LegMaturityTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegMaturityTime *)new FIX::LegMaturityTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegMaturityTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegMaturityTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegMaturityTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegMaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityTime";
  FIX::LegMaturityTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TZTIMEONLY const &","FIX::LegMaturityTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TZTIMEONLY const &","FIX::LegMaturityTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::LegMaturityTime *)new FIX::LegMaturityTime((FIX::TZTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegMaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegMaturityTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegMaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegMaturityTime.new", 
    "    LegMaturityTime.new()\n"
    "    LegMaturityTime.new(FIX::TZTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegMaturityTime(FIX::LegMaturityTime *arg1) {
    delete arg1;
}

swig_class SwigClassSettlDeliveryType;

SWIGINTERN VALUE
_wrap_new_SettlDeliveryType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlDeliveryType";
  FIX::SettlDeliveryType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlDeliveryType *)new FIX::SettlDeliveryType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlDeliveryType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlDeliveryType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlDeliveryType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlDeliveryType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDeliveryType";
  FIX::SettlDeliveryType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlDeliveryType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlDeliveryType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlDeliveryType *)new FIX::SettlDeliveryType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlDeliveryType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlDeliveryType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDeliveryType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlDeliveryType.new", 
    "    SettlDeliveryType.new()\n"
    "    SettlDeliveryType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDeliveryType(FIX::SettlDeliveryType *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryPriceLimitType;

SWIGINTERN VALUE
_wrap_new_SecondaryPriceLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryPriceLimitType";
  FIX::SecondaryPriceLimitType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryPriceLimitType *)new FIX::SecondaryPriceLimitType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryPriceLimitType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryPriceLimitType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryPriceLimitType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryPriceLimitType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryPriceLimitType";
  FIX::SecondaryPriceLimitType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecondaryPriceLimitType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecondaryPriceLimitType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecondaryPriceLimitType *)new FIX::SecondaryPriceLimitType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryPriceLimitType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryPriceLimitType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryPriceLimitType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryPriceLimitType.new", 
    "    SecondaryPriceLimitType.new()\n"
    "    SecondaryPriceLimitType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryPriceLimitType(FIX::SecondaryPriceLimitType *arg1) {
    delete arg1;
}

swig_class SwigClassMidPx;

SWIGINTERN VALUE
_wrap_new_MidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MidPx";
  FIX::MidPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MidPx *)new FIX::MidPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MidPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MidPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MidPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MidPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MidPx";
  FIX::MidPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::MidPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::MidPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::MidPx *)new FIX::MidPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MidPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MidPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MidPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MidPx.new", 
    "    MidPx.new()\n"
    "    MidPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MidPx(FIX::MidPx *arg1) {
    delete arg1;
}

swig_class SwigClassAvgPx;

SWIGINTERN VALUE
_wrap_new_AvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AvgPx";
  FIX::AvgPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AvgPx *)new FIX::AvgPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AvgPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AvgPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AvgPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AvgPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPx";
  FIX::AvgPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::AvgPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::AvgPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::AvgPx *)new FIX::AvgPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AvgPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AvgPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AvgPx.new", 
    "    AvgPx.new()\n"
    "    AvgPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPx(FIX::AvgPx *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionLimitType;

SWIGINTERN VALUE
_wrap_new_DiscretionLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionLimitType";
  FIX::DiscretionLimitType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionLimitType *)new FIX::DiscretionLimitType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionLimitType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionLimitType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionLimitType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionLimitType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionLimitType";
  FIX::DiscretionLimitType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DiscretionLimitType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DiscretionLimitType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DiscretionLimitType *)new FIX::DiscretionLimitType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionLimitType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionLimitType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionLimitType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionLimitType.new", 
    "    DiscretionLimitType.new()\n"
    "    DiscretionLimitType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionLimitType(FIX::DiscretionLimitType *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeTime;

SWIGINTERN VALUE
_wrap_new_StrikeTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  FIX::StrikeTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeTime *)new FIX::StrikeTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_StrikeTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  FIX::StrikeTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::StrikeTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::StrikeTime *)new FIX::StrikeTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_StrikeTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  FIX::StrikeTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::StrikeTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::StrikeTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::StrikeTime *)new FIX::StrikeTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  FIX::StrikeTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::StrikeTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::StrikeTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::StrikeTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::StrikeTime *)new FIX::StrikeTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StrikeTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_StrikeTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StrikeTime.new", 
    "    StrikeTime.new()\n"
    "    StrikeTime.new(bool showMilliseconds)\n"
    "    StrikeTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    StrikeTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeTime(FIX::StrikeTime *arg1) {
    delete arg1;
}

swig_class SwigClassSettlSessSubID;

SWIGINTERN VALUE
_wrap_new_SettlSessSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlSessSubID";
  FIX::SettlSessSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlSessSubID *)new FIX::SettlSessSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlSessSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlSessSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlSessSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlSessSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlSessSubID";
  FIX::SettlSessSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlSessSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlSessSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlSessSubID *)new FIX::SettlSessSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlSessSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlSessSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlSessSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlSessSubID.new", 
    "    SettlSessSubID.new()\n"
    "    SettlSessSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlSessSubID(FIX::SettlSessSubID *arg1) {
    delete arg1;
}

swig_class SwigClassMailingDtls;

SWIGINTERN VALUE
_wrap_new_MailingDtls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MailingDtls";
  FIX::MailingDtls *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MailingDtls *)new FIX::MailingDtls();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MailingDtls_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MailingDtls_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MailingDtls);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MailingDtls__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MailingDtls";
  FIX::MailingDtls *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MailingDtls", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MailingDtls", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MailingDtls *)new FIX::MailingDtls((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MailingDtls(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MailingDtls__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MailingDtls__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MailingDtls.new", 
    "    MailingDtls.new()\n"
    "    MailingDtls.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MailingDtls(FIX::MailingDtls *arg1) {
    delete arg1;
}

swig_class SwigClassBidID;

SWIGINTERN VALUE
_wrap_new_BidID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidID";
  FIX::BidID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidID *)new FIX::BidID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidID";
  FIX::BidID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BidID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BidID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BidID *)new FIX::BidID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidID.new", 
    "    BidID.new()\n"
    "    BidID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidID(FIX::BidID *arg1) {
    delete arg1;
}

swig_class SwigClassExerciseMethod;

SWIGINTERN VALUE
_wrap_new_ExerciseMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExerciseMethod";
  FIX::ExerciseMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExerciseMethod *)new FIX::ExerciseMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExerciseMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExerciseMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExerciseMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExerciseMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExerciseMethod";
  FIX::ExerciseMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExerciseMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExerciseMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExerciseMethod *)new FIX::ExerciseMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExerciseMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExerciseMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExerciseMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExerciseMethod.new", 
    "    ExerciseMethod.new()\n"
    "    ExerciseMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExerciseMethod(FIX::ExerciseMethod *arg1) {
    delete arg1;
}

swig_class SwigClassCommCurrency;

SWIGINTERN VALUE
_wrap_new_CommCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CommCurrency";
  FIX::CommCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CommCurrency *)new FIX::CommCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CommCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CommCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CommCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CommCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CommCurrency";
  FIX::CommCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::CommCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::CommCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::CommCurrency *)new FIX::CommCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CommCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CommCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CommCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CommCurrency.new", 
    "    CommCurrency.new()\n"
    "    CommCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CommCurrency(FIX::CommCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassNoSettlOblig;

SWIGINTERN VALUE
_wrap_new_NoSettlOblig__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSettlOblig";
  FIX::NoSettlOblig *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSettlOblig *)new FIX::NoSettlOblig();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSettlOblig_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSettlOblig_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSettlOblig);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSettlOblig__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlOblig";
  FIX::NoSettlOblig *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSettlOblig", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSettlOblig", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSettlOblig *)new FIX::NoSettlOblig((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSettlOblig(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSettlOblig__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlOblig__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSettlOblig.new", 
    "    NoSettlOblig.new()\n"
    "    NoSettlOblig.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlOblig(FIX::NoSettlOblig *arg1) {
    delete arg1;
}

swig_class SwigClassMaxPriceVariation;

SWIGINTERN VALUE
_wrap_new_MaxPriceVariation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceVariation";
  FIX::MaxPriceVariation *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaxPriceVariation *)new FIX::MaxPriceVariation();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaxPriceVariation_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaxPriceVariation_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaxPriceVariation);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaxPriceVariation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceVariation";
  FIX::MaxPriceVariation *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::MaxPriceVariation", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::MaxPriceVariation", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::MaxPriceVariation *)new FIX::MaxPriceVariation((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaxPriceVariation(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaxPriceVariation__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxPriceVariation__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaxPriceVariation.new", 
    "    MaxPriceVariation.new()\n"
    "    MaxPriceVariation.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxPriceVariation(FIX::MaxPriceVariation *arg1) {
    delete arg1;
}

swig_class SwigClassWorkingIndicator;

SWIGINTERN VALUE
_wrap_new_WorkingIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::WorkingIndicator";
  FIX::WorkingIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::WorkingIndicator *)new FIX::WorkingIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_WorkingIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_WorkingIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__WorkingIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_WorkingIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WorkingIndicator";
  FIX::WorkingIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::WorkingIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::WorkingIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::WorkingIndicator *)new FIX::WorkingIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_WorkingIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_WorkingIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WorkingIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "WorkingIndicator.new", 
    "    WorkingIndicator.new()\n"
    "    WorkingIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_WorkingIndicator(FIX::WorkingIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassCashSettlAgentAcctName;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentAcctName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctName";
  FIX::CashSettlAgentAcctName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashSettlAgentAcctName *)new FIX::CashSettlAgentAcctName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashSettlAgentAcctName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashSettlAgentAcctName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashSettlAgentAcctName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashSettlAgentAcctName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctName";
  FIX::CashSettlAgentAcctName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashSettlAgentAcctName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashSettlAgentAcctName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashSettlAgentAcctName *)new FIX::CashSettlAgentAcctName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashSettlAgentAcctName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashSettlAgentAcctName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentAcctName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashSettlAgentAcctName.new", 
    "    CashSettlAgentAcctName.new()\n"
    "    CashSettlAgentAcctName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentAcctName(FIX::CashSettlAgentAcctName *arg1) {
    delete arg1;
}

swig_class SwigClassSellVolume;

SWIGINTERN VALUE
_wrap_new_SellVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SellVolume";
  FIX::SellVolume *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SellVolume *)new FIX::SellVolume();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SellVolume_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SellVolume_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SellVolume);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SellVolume__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SellVolume";
  FIX::SellVolume *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::SellVolume", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::SellVolume", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::SellVolume *)new FIX::SellVolume((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SellVolume(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SellVolume__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SellVolume__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SellVolume.new", 
    "    SellVolume.new()\n"
    "    SellVolume.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SellVolume(FIX::SellVolume *arg1) {
    delete arg1;
}

swig_class SwigClassSideMultiLegReportingType;

SWIGINTERN VALUE
_wrap_new_SideMultiLegReportingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideMultiLegReportingType";
  FIX::SideMultiLegReportingType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideMultiLegReportingType *)new FIX::SideMultiLegReportingType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideMultiLegReportingType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideMultiLegReportingType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideMultiLegReportingType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideMultiLegReportingType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideMultiLegReportingType";
  FIX::SideMultiLegReportingType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideMultiLegReportingType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideMultiLegReportingType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideMultiLegReportingType *)new FIX::SideMultiLegReportingType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideMultiLegReportingType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideMultiLegReportingType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideMultiLegReportingType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideMultiLegReportingType.new", 
    "    SideMultiLegReportingType.new()\n"
    "    SideMultiLegReportingType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideMultiLegReportingType(FIX::SideMultiLegReportingType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEventText;

SWIGINTERN VALUE
_wrap_new_DerivativeEventText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventText";
  FIX::DerivativeEventText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEventText *)new FIX::DerivativeEventText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEventText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEventText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEventText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEventText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventText";
  FIX::DerivativeEventText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeEventText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeEventText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeEventText *)new FIX::DerivativeEventText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEventText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEventText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEventText.new", 
    "    DerivativeEventText.new()\n"
    "    DerivativeEventText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventText(FIX::DerivativeEventText *arg1) {
    delete arg1;
}

swig_class SwigClassPegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_PegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityDesc";
  FIX::PegSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegSecurityDesc *)new FIX::PegSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityDesc";
  FIX::PegSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PegSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PegSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PegSecurityDesc *)new FIX::PegSecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegSecurityDesc.new", 
    "    PegSecurityDesc.new()\n"
    "    PegSecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSecurityDesc(FIX::PegSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassAllocCustomerCapacity;

SWIGINTERN VALUE
_wrap_new_AllocCustomerCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocCustomerCapacity";
  FIX::AllocCustomerCapacity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocCustomerCapacity *)new FIX::AllocCustomerCapacity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocCustomerCapacity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocCustomerCapacity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocCustomerCapacity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocCustomerCapacity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocCustomerCapacity";
  FIX::AllocCustomerCapacity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocCustomerCapacity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocCustomerCapacity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocCustomerCapacity *)new FIX::AllocCustomerCapacity((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocCustomerCapacity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocCustomerCapacity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocCustomerCapacity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocCustomerCapacity.new", 
    "    AllocCustomerCapacity.new()\n"
    "    AllocCustomerCapacity.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocCustomerCapacity(FIX::AllocCustomerCapacity *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmRejReason;

SWIGINTERN VALUE
_wrap_new_ConfirmRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRejReason";
  FIX::ConfirmRejReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmRejReason *)new FIX::ConfirmRejReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmRejReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmRejReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmRejReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmRejReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRejReason";
  FIX::ConfirmRejReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ConfirmRejReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ConfirmRejReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ConfirmRejReason *)new FIX::ConfirmRejReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmRejReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmRejReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmRejReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmRejReason.new", 
    "    ConfirmRejReason.new()\n"
    "    ConfirmRejReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmRejReason(FIX::ConfirmRejReason *arg1) {
    delete arg1;
}

swig_class SwigClassBidRequestTransType;

SWIGINTERN VALUE
_wrap_new_BidRequestTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidRequestTransType";
  FIX::BidRequestTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidRequestTransType *)new FIX::BidRequestTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidRequestTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidRequestTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidRequestTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidRequestTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidRequestTransType";
  FIX::BidRequestTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::BidRequestTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::BidRequestTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::BidRequestTransType *)new FIX::BidRequestTransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidRequestTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidRequestTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidRequestTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidRequestTransType.new", 
    "    BidRequestTransType.new()\n"
    "    BidRequestTransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidRequestTransType(FIX::BidRequestTransType *arg1) {
    delete arg1;
}

swig_class SwigClassCashDistribAgentAcctNumber;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentAcctNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctNumber";
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashDistribAgentAcctNumber *)new FIX::CashDistribAgentAcctNumber();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashDistribAgentAcctNumber_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashDistribAgentAcctNumber_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashDistribAgentAcctNumber);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashDistribAgentAcctNumber__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctNumber";
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashDistribAgentAcctNumber", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashDistribAgentAcctNumber", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashDistribAgentAcctNumber *)new FIX::CashDistribAgentAcctNumber((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashDistribAgentAcctNumber(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashDistribAgentAcctNumber__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentAcctNumber__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashDistribAgentAcctNumber.new", 
    "    CashDistribAgentAcctNumber.new()\n"
    "    CashDistribAgentAcctNumber.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentAcctNumber(FIX::CashDistribAgentAcctNumber *arg1) {
    delete arg1;
}

swig_class SwigClassLegExecInst;

SWIGINTERN VALUE
_wrap_new_LegExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegExecInst";
  FIX::LegExecInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegExecInst *)new FIX::LegExecInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegExecInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegExecInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegExecInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegExecInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegExecInst";
  FIX::LegExecInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::LegExecInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::LegExecInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::LegExecInst *)new FIX::LegExecInst((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegExecInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegExecInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegExecInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegExecInst.new", 
    "    LegExecInst.new()\n"
    "    LegExecInst.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegExecInst(FIX::LegExecInst *arg1) {
    delete arg1;
}

swig_class SwigClassCapPrice;

SWIGINTERN VALUE
_wrap_new_CapPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CapPrice";
  FIX::CapPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CapPrice *)new FIX::CapPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CapPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CapPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CapPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CapPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CapPrice";
  FIX::CapPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::CapPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::CapPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::CapPrice *)new FIX::CapPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CapPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CapPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CapPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CapPrice.new", 
    "    CapPrice.new()\n"
    "    CapPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CapPrice(FIX::CapPrice *arg1) {
    delete arg1;
}

swig_class SwigClassLegRepurchaseTerm;

SWIGINTERN VALUE
_wrap_new_LegRepurchaseTerm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseTerm";
  FIX::LegRepurchaseTerm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegRepurchaseTerm *)new FIX::LegRepurchaseTerm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegRepurchaseTerm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegRepurchaseTerm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegRepurchaseTerm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegRepurchaseTerm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseTerm";
  FIX::LegRepurchaseTerm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegRepurchaseTerm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegRepurchaseTerm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegRepurchaseTerm *)new FIX::LegRepurchaseTerm((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegRepurchaseTerm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegRepurchaseTerm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepurchaseTerm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegRepurchaseTerm.new", 
    "    LegRepurchaseTerm.new()\n"
    "    LegRepurchaseTerm.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRepurchaseTerm(FIX::LegRepurchaseTerm *arg1) {
    delete arg1;
}

swig_class SwigClassRegistAcctType;

SWIGINTERN VALUE
_wrap_new_RegistAcctType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistAcctType";
  FIX::RegistAcctType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistAcctType *)new FIX::RegistAcctType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistAcctType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistAcctType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistAcctType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistAcctType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistAcctType";
  FIX::RegistAcctType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistAcctType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistAcctType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistAcctType *)new FIX::RegistAcctType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistAcctType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistAcctType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistAcctType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistAcctType.new", 
    "    RegistAcctType.new()\n"
    "    RegistAcctType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistAcctType(FIX::RegistAcctType *arg1) {
    delete arg1;
}

swig_class SwigClassMassActionRejectReason;

SWIGINTERN VALUE
_wrap_new_MassActionRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassActionRejectReason";
  FIX::MassActionRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassActionRejectReason *)new FIX::MassActionRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassActionRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassActionRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassActionRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassActionRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionRejectReason";
  FIX::MassActionRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MassActionRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MassActionRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MassActionRejectReason *)new FIX::MassActionRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassActionRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassActionRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassActionRejectReason.new", 
    "    MassActionRejectReason.new()\n"
    "    MassActionRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionRejectReason(FIX::MassActionRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativePutOrCall;

SWIGINTERN VALUE
_wrap_new_DerivativePutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativePutOrCall";
  FIX::DerivativePutOrCall *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativePutOrCall *)new FIX::DerivativePutOrCall();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativePutOrCall_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativePutOrCall_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativePutOrCall);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativePutOrCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePutOrCall";
  FIX::DerivativePutOrCall *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativePutOrCall", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativePutOrCall", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativePutOrCall *)new FIX::DerivativePutOrCall((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativePutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativePutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativePutOrCall.new", 
    "    DerivativePutOrCall.new()\n"
    "    DerivativePutOrCall.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePutOrCall(FIX::DerivativePutOrCall *arg1) {
    delete arg1;
}

swig_class SwigClassStartMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_StartMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StartMaturityMonthYear";
  FIX::StartMaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StartMaturityMonthYear *)new FIX::StartMaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StartMaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StartMaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StartMaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StartMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartMaturityMonthYear";
  FIX::StartMaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::StartMaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::StartMaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::StartMaturityMonthYear *)new FIX::StartMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StartMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StartMaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StartMaturityMonthYear.new", 
    "    StartMaturityMonthYear.new()\n"
    "    StartMaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StartMaturityMonthYear(FIX::StartMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassCollApplType;

SWIGINTERN VALUE
_wrap_new_CollApplType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollApplType";
  FIX::CollApplType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollApplType *)new FIX::CollApplType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollApplType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollApplType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollApplType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollApplType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollApplType";
  FIX::CollApplType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollApplType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollApplType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollApplType *)new FIX::CollApplType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollApplType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollApplType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollApplType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollApplType.new", 
    "    CollApplType.new()\n"
    "    CollApplType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollApplType(FIX::CollApplType *arg1) {
    delete arg1;
}

swig_class SwigClassNoUnderlyingAmounts;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingAmounts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingAmounts";
  FIX::NoUnderlyingAmounts *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUnderlyingAmounts *)new FIX::NoUnderlyingAmounts();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUnderlyingAmounts_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUnderlyingAmounts_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUnderlyingAmounts);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUnderlyingAmounts__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingAmounts";
  FIX::NoUnderlyingAmounts *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUnderlyingAmounts", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUnderlyingAmounts", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUnderlyingAmounts *)new FIX::NoUnderlyingAmounts((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUnderlyingAmounts(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUnderlyingAmounts__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingAmounts__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUnderlyingAmounts.new", 
    "    NoUnderlyingAmounts.new()\n"
    "    NoUnderlyingAmounts.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingAmounts(FIX::NoUnderlyingAmounts *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmType;

SWIGINTERN VALUE
_wrap_new_ConfirmType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmType";
  FIX::ConfirmType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmType *)new FIX::ConfirmType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmType";
  FIX::ConfirmType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ConfirmType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ConfirmType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ConfirmType *)new FIX::ConfirmType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmType.new", 
    "    ConfirmType.new()\n"
    "    ConfirmType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmType(FIX::ConfirmType *arg1) {
    delete arg1;
}

swig_class SwigClassLegMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_LegMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityMonthYear";
  FIX::LegMaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegMaturityMonthYear *)new FIX::LegMaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegMaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegMaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegMaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityMonthYear";
  FIX::LegMaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::LegMaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::LegMaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::LegMaturityMonthYear *)new FIX::LegMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegMaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegMaturityMonthYear.new", 
    "    LegMaturityMonthYear.new()\n"
    "    LegMaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegMaturityMonthYear(FIX::LegMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassRelatdSym;

SWIGINTERN VALUE
_wrap_new_RelatdSym__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RelatdSym";
  FIX::RelatdSym *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RelatdSym *)new FIX::RelatdSym();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RelatdSym_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RelatdSym_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RelatdSym);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RelatdSym__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelatdSym";
  FIX::RelatdSym *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RelatdSym", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RelatdSym", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RelatdSym *)new FIX::RelatdSym((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelatdSym(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatdSym__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatdSym__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RelatdSym.new", 
    "    RelatdSym.new()\n"
    "    RelatdSym.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatdSym(FIX::RelatdSym *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecuritySubType;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecuritySubType";
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecuritySubType *)new FIX::UnderlyingLegSecuritySubType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecuritySubType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecuritySubType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecuritySubType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecuritySubType";
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecuritySubType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecuritySubType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecuritySubType *)new FIX::UnderlyingLegSecuritySubType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecuritySubType.new", 
    "    UnderlyingLegSecuritySubType.new()\n"
    "    UnderlyingLegSecuritySubType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecuritySubType(FIX::UnderlyingLegSecuritySubType *arg1) {
    delete arg1;
}

swig_class SwigClassNoUnderlyingSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingSecurityAltID";
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUnderlyingSecurityAltID *)new FIX::NoUnderlyingSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUnderlyingSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUnderlyingSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUnderlyingSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingSecurityAltID";
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUnderlyingSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUnderlyingSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUnderlyingSecurityAltID *)new FIX::NoUnderlyingSecurityAltID((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUnderlyingSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUnderlyingSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUnderlyingSecurityAltID.new", 
    "    NoUnderlyingSecurityAltID.new()\n"
    "    NoUnderlyingSecurityAltID.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingSecurityAltID(FIX::NoUnderlyingSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassMDQuoteType;

SWIGINTERN VALUE
_wrap_new_MDQuoteType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDQuoteType";
  FIX::MDQuoteType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDQuoteType *)new FIX::MDQuoteType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDQuoteType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDQuoteType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDQuoteType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDQuoteType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDQuoteType";
  FIX::MDQuoteType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDQuoteType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDQuoteType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDQuoteType *)new FIX::MDQuoteType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDQuoteType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDQuoteType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDQuoteType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDQuoteType.new", 
    "    MDQuoteType.new()\n"
    "    MDQuoteType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDQuoteType(FIX::MDQuoteType *arg1) {
    delete arg1;
}

swig_class SwigClassQtyType;

SWIGINTERN VALUE
_wrap_new_QtyType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QtyType";
  FIX::QtyType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QtyType *)new FIX::QtyType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QtyType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QtyType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QtyType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QtyType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QtyType";
  FIX::QtyType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QtyType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QtyType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QtyType *)new FIX::QtyType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QtyType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QtyType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QtyType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QtyType.new", 
    "    QtyType.new()\n"
    "    QtyType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QtyType(FIX::QtyType *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteRespType;

SWIGINTERN VALUE
_wrap_new_QuoteRespType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespType";
  FIX::QuoteRespType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteRespType *)new FIX::QuoteRespType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteRespType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteRespType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteRespType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteRespType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespType";
  FIX::QuoteRespType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteRespType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteRespType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteRespType *)new FIX::QuoteRespType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteRespType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteRespType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRespType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteRespType.new", 
    "    QuoteRespType.new()\n"
    "    QuoteRespType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRespType(FIX::QuoteRespType *arg1) {
    delete arg1;
}

swig_class SwigClassIOINaturalFlag;

SWIGINTERN VALUE
_wrap_new_IOINaturalFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOINaturalFlag";
  FIX::IOINaturalFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOINaturalFlag *)new FIX::IOINaturalFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOINaturalFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOINaturalFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOINaturalFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOINaturalFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOINaturalFlag";
  FIX::IOINaturalFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::IOINaturalFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::IOINaturalFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::IOINaturalFlag *)new FIX::IOINaturalFlag((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOINaturalFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOINaturalFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOINaturalFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOINaturalFlag.new", 
    "    IOINaturalFlag.new()\n"
    "    IOINaturalFlag.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOINaturalFlag(FIX::IOINaturalFlag *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkCurvePoint;

SWIGINTERN VALUE
_wrap_new_BenchmarkCurvePoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurvePoint";
  FIX::BenchmarkCurvePoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkCurvePoint *)new FIX::BenchmarkCurvePoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkCurvePoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkCurvePoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkCurvePoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkCurvePoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurvePoint";
  FIX::BenchmarkCurvePoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BenchmarkCurvePoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BenchmarkCurvePoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BenchmarkCurvePoint *)new FIX::BenchmarkCurvePoint((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkCurvePoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkCurvePoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkCurvePoint__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkCurvePoint.new", 
    "    BenchmarkCurvePoint.new()\n"
    "    BenchmarkCurvePoint.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkCurvePoint(FIX::BenchmarkCurvePoint *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesUpdateAction;

SWIGINTERN VALUE
_wrap_new_TradSesUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesUpdateAction";
  FIX::TradSesUpdateAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesUpdateAction *)new FIX::TradSesUpdateAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesUpdateAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesUpdateAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesUpdateAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesUpdateAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesUpdateAction";
  FIX::TradSesUpdateAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TradSesUpdateAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TradSesUpdateAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TradSesUpdateAction *)new FIX::TradSesUpdateAction((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesUpdateAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesUpdateAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesUpdateAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesUpdateAction.new", 
    "    TradSesUpdateAction.new()\n"
    "    TradSesUpdateAction.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesUpdateAction(FIX::TradSesUpdateAction *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCashAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingCashAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashAmount";
  FIX::UnderlyingCashAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCashAmount *)new FIX::UnderlyingCashAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCashAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCashAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCashAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCashAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashAmount";
  FIX::UnderlyingCashAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingCashAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingCashAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingCashAmount *)new FIX::UnderlyingCashAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCashAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCashAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCashAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCashAmount.new", 
    "    UnderlyingCashAmount.new()\n"
    "    UnderlyingCashAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCashAmount(FIX::UnderlyingCashAmount *arg1) {
    delete arg1;
}

swig_class SwigClassCollAsgnID;

SWIGINTERN VALUE
_wrap_new_CollAsgnID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnID";
  FIX::CollAsgnID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAsgnID *)new FIX::CollAsgnID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAsgnID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAsgnID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAsgnID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAsgnID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnID";
  FIX::CollAsgnID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CollAsgnID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CollAsgnID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CollAsgnID *)new FIX::CollAsgnID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAsgnID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAsgnID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAsgnID.new", 
    "    CollAsgnID.new()\n"
    "    CollAsgnID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnID(FIX::CollAsgnID *arg1) {
    delete arg1;
}

swig_class SwigClassExchangeRule;

SWIGINTERN VALUE
_wrap_new_ExchangeRule__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExchangeRule";
  FIX::ExchangeRule *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExchangeRule *)new FIX::ExchangeRule();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExchangeRule_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExchangeRule_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExchangeRule);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExchangeRule__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeRule";
  FIX::ExchangeRule *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ExchangeRule", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ExchangeRule", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ExchangeRule *)new FIX::ExchangeRule((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExchangeRule(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExchangeRule__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExchangeRule__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExchangeRule.new", 
    "    ExchangeRule.new()\n"
    "    ExchangeRule.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExchangeRule(FIX::ExchangeRule *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedHeadline;

SWIGINTERN VALUE
_wrap_new_EncodedHeadline__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadline";
  FIX::EncodedHeadline *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedHeadline *)new FIX::EncodedHeadline();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedHeadline_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedHeadline_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedHeadline);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedHeadline__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadline";
  FIX::EncodedHeadline *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedHeadline", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedHeadline", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedHeadline *)new FIX::EncodedHeadline((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedHeadline(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedHeadline__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedHeadline__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedHeadline.new", 
    "    EncodedHeadline.new()\n"
    "    EncodedHeadline.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedHeadline(FIX::EncodedHeadline *arg1) {
    delete arg1;
}

swig_class SwigClassRegistID;

SWIGINTERN VALUE
_wrap_new_RegistID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistID";
  FIX::RegistID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistID *)new FIX::RegistID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistID";
  FIX::RegistID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistID *)new FIX::RegistID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistID.new", 
    "    RegistID.new()\n"
    "    RegistID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistID(FIX::RegistID *arg1) {
    delete arg1;
}

swig_class SwigClassCrossID;

SWIGINTERN VALUE
_wrap_new_CrossID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CrossID";
  FIX::CrossID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CrossID *)new FIX::CrossID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CrossID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CrossID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CrossID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CrossID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossID";
  FIX::CrossID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CrossID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CrossID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CrossID *)new FIX::CrossID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CrossID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CrossID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CrossID.new", 
    "    CrossID.new()\n"
    "    CrossID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossID(FIX::CrossID *arg1) {
    delete arg1;
}

swig_class SwigClassNoExecs;

SWIGINTERN VALUE
_wrap_new_NoExecs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoExecs";
  FIX::NoExecs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoExecs *)new FIX::NoExecs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoExecs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoExecs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoExecs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoExecs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExecs";
  FIX::NoExecs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoExecs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoExecs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoExecs *)new FIX::NoExecs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoExecs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoExecs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoExecs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoExecs.new", 
    "    NoExecs.new()\n"
    "    NoExecs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoExecs(FIX::NoExecs *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityGroup;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityGroup";
  FIX::DerivativeSecurityGroup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityGroup *)new FIX::DerivativeSecurityGroup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityGroup_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityGroup_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityGroup);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityGroup";
  FIX::DerivativeSecurityGroup *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityGroup", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityGroup", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityGroup *)new FIX::DerivativeSecurityGroup((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityGroup__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityGroup__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityGroup.new", 
    "    DerivativeSecurityGroup.new()\n"
    "    DerivativeSecurityGroup.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityGroup(FIX::DerivativeSecurityGroup *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryDisplayQty;

SWIGINTERN VALUE
_wrap_new_SecondaryDisplayQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryDisplayQty";
  FIX::SecondaryDisplayQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryDisplayQty *)new FIX::SecondaryDisplayQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryDisplayQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryDisplayQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryDisplayQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryDisplayQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryDisplayQty";
  FIX::SecondaryDisplayQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::SecondaryDisplayQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::SecondaryDisplayQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::SecondaryDisplayQty *)new FIX::SecondaryDisplayQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryDisplayQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryDisplayQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryDisplayQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryDisplayQty.new", 
    "    SecondaryDisplayQty.new()\n"
    "    SecondaryDisplayQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryDisplayQty(FIX::SecondaryDisplayQty *arg1) {
    delete arg1;
}

swig_class SwigClassRefMsgType;

SWIGINTERN VALUE
_wrap_new_RefMsgType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefMsgType";
  FIX::RefMsgType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefMsgType *)new FIX::RefMsgType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefMsgType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefMsgType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefMsgType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefMsgType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefMsgType";
  FIX::RefMsgType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefMsgType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefMsgType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefMsgType *)new FIX::RefMsgType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefMsgType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefMsgType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefMsgType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefMsgType.new", 
    "    RefMsgType.new()\n"
    "    RefMsgType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefMsgType(FIX::RefMsgType *arg1) {
    delete arg1;
}

swig_class SwigClassStandInstDbID;

SWIGINTERN VALUE
_wrap_new_StandInstDbID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbID";
  FIX::StandInstDbID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StandInstDbID *)new FIX::StandInstDbID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StandInstDbID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StandInstDbID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StandInstDbID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StandInstDbID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbID";
  FIX::StandInstDbID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StandInstDbID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StandInstDbID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StandInstDbID *)new FIX::StandInstDbID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StandInstDbID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StandInstDbID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StandInstDbID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StandInstDbID.new", 
    "    StandInstDbID.new()\n"
    "    StandInstDbID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StandInstDbID(FIX::StandInstDbID *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedLegSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedLegSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDescLen";
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedLegSecurityDescLen *)new FIX::EncodedLegSecurityDescLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedLegSecurityDescLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedLegSecurityDescLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedLegSecurityDescLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedLegSecurityDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDescLen";
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedLegSecurityDescLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedLegSecurityDescLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedLegSecurityDescLen *)new FIX::EncodedLegSecurityDescLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedLegSecurityDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedLegSecurityDescLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegSecurityDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedLegSecurityDescLen.new", 
    "    EncodedLegSecurityDescLen.new()\n"
    "    EncodedLegSecurityDescLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegSecurityDescLen(FIX::EncodedLegSecurityDescLen *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEventPx;

SWIGINTERN VALUE
_wrap_new_DerivativeEventPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventPx";
  FIX::DerivativeEventPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEventPx *)new FIX::DerivativeEventPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEventPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEventPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEventPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEventPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventPx";
  FIX::DerivativeEventPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::DerivativeEventPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::DerivativeEventPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::DerivativeEventPx *)new FIX::DerivativeEventPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEventPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEventPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEventPx.new", 
    "    DerivativeEventPx.new()\n"
    "    DerivativeEventPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventPx(FIX::DerivativeEventPx *arg1) {
    delete arg1;
}

swig_class SwigClassSettlObligSource;

SWIGINTERN VALUE
_wrap_new_SettlObligSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlObligSource";
  FIX::SettlObligSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlObligSource *)new FIX::SettlObligSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlObligSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlObligSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlObligSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlObligSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligSource";
  FIX::SettlObligSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlObligSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlObligSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlObligSource *)new FIX::SettlObligSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlObligSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlObligSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlObligSource.new", 
    "    SettlObligSource.new()\n"
    "    SettlObligSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligSource(FIX::SettlObligSource *arg1) {
    delete arg1;
}

swig_class SwigClassTrdSubType;

SWIGINTERN VALUE
_wrap_new_TrdSubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdSubType";
  FIX::TrdSubType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdSubType *)new FIX::TrdSubType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdSubType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdSubType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdSubType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdSubType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdSubType";
  FIX::TrdSubType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TrdSubType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TrdSubType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TrdSubType *)new FIX::TrdSubType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdSubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdSubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdSubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdSubType.new", 
    "    TrdSubType.new()\n"
    "    TrdSubType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdSubType(FIX::TrdSubType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedUnderlyingIssuerLen;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuerLen";
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedUnderlyingIssuerLen *)new FIX::EncodedUnderlyingIssuerLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedUnderlyingIssuerLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedUnderlyingIssuerLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingIssuerLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuerLen";
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedUnderlyingIssuerLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedUnderlyingIssuerLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedUnderlyingIssuerLen *)new FIX::EncodedUnderlyingIssuerLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedUnderlyingIssuerLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedUnderlyingIssuerLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingIssuerLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedUnderlyingIssuerLen.new", 
    "    EncodedUnderlyingIssuerLen.new()\n"
    "    EncodedUnderlyingIssuerLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingIssuerLen(FIX::EncodedUnderlyingIssuerLen *arg1) {
    delete arg1;
}

swig_class SwigClassExecTransType;

SWIGINTERN VALUE
_wrap_new_ExecTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecTransType";
  FIX::ExecTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecTransType *)new FIX::ExecTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecTransType";
  FIX::ExecTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExecTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExecTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExecTransType *)new FIX::ExecTransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecTransType.new", 
    "    ExecTransType.new()\n"
    "    ExecTransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecTransType(FIX::ExecTransType *arg1) {
    delete arg1;
}

swig_class SwigClassBeginSeqNo;

SWIGINTERN VALUE
_wrap_new_BeginSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BeginSeqNo";
  FIX::BeginSeqNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BeginSeqNo *)new FIX::BeginSeqNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BeginSeqNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BeginSeqNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BeginSeqNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BeginSeqNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BeginSeqNo";
  FIX::BeginSeqNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::BeginSeqNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::BeginSeqNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::BeginSeqNo *)new FIX::BeginSeqNo((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BeginSeqNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BeginSeqNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BeginSeqNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BeginSeqNo.new", 
    "    BeginSeqNo.new()\n"
    "    BeginSeqNo.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BeginSeqNo(FIX::BeginSeqNo *arg1) {
    delete arg1;
}

swig_class SwigClassDayBookingInst;

SWIGINTERN VALUE
_wrap_new_DayBookingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DayBookingInst";
  FIX::DayBookingInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DayBookingInst *)new FIX::DayBookingInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DayBookingInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DayBookingInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DayBookingInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DayBookingInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayBookingInst";
  FIX::DayBookingInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DayBookingInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DayBookingInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DayBookingInst *)new FIX::DayBookingInst((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DayBookingInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DayBookingInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayBookingInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DayBookingInst.new", 
    "    DayBookingInst.new()\n"
    "    DayBookingInst.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DayBookingInst(FIX::DayBookingInst *arg1) {
    delete arg1;
}

swig_class SwigClassFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_FlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FlowScheduleType";
  FIX::FlowScheduleType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FlowScheduleType *)new FIX::FlowScheduleType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FlowScheduleType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FlowScheduleType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FlowScheduleType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FlowScheduleType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlowScheduleType";
  FIX::FlowScheduleType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::FlowScheduleType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::FlowScheduleType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::FlowScheduleType *)new FIX::FlowScheduleType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FlowScheduleType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FlowScheduleType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FlowScheduleType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FlowScheduleType.new", 
    "    FlowScheduleType.new()\n"
    "    FlowScheduleType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FlowScheduleType(FIX::FlowScheduleType *arg1) {
    delete arg1;
}

swig_class SwigClassMDOriginType;

SWIGINTERN VALUE
_wrap_new_MDOriginType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDOriginType";
  FIX::MDOriginType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDOriginType *)new FIX::MDOriginType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDOriginType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDOriginType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDOriginType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDOriginType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDOriginType";
  FIX::MDOriginType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDOriginType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDOriginType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDOriginType *)new FIX::MDOriginType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDOriginType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDOriginType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDOriginType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDOriginType.new", 
    "    MDOriginType.new()\n"
    "    MDOriginType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDOriginType(FIX::MDOriginType *arg1) {
    delete arg1;
}

swig_class SwigClassCollInquiryStatus;

SWIGINTERN VALUE
_wrap_new_CollInquiryStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryStatus";
  FIX::CollInquiryStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollInquiryStatus *)new FIX::CollInquiryStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollInquiryStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollInquiryStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollInquiryStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollInquiryStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryStatus";
  FIX::CollInquiryStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollInquiryStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollInquiryStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollInquiryStatus *)new FIX::CollInquiryStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollInquiryStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollInquiryStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollInquiryStatus.new", 
    "    CollInquiryStatus.new()\n"
    "    CollInquiryStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryStatus(FIX::CollInquiryStatus *arg1) {
    delete arg1;
}

swig_class SwigClassNoInstrAttrib;

SWIGINTERN VALUE
_wrap_new_NoInstrAttrib__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoInstrAttrib";
  FIX::NoInstrAttrib *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoInstrAttrib *)new FIX::NoInstrAttrib();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoInstrAttrib_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoInstrAttrib_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoInstrAttrib);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoInstrAttrib__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrAttrib";
  FIX::NoInstrAttrib *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoInstrAttrib", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoInstrAttrib", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoInstrAttrib *)new FIX::NoInstrAttrib((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoInstrAttrib(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoInstrAttrib__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoInstrAttrib__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoInstrAttrib.new", 
    "    NoInstrAttrib.new()\n"
    "    NoInstrAttrib.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoInstrAttrib(FIX::NoInstrAttrib *arg1) {
    delete arg1;
}

swig_class SwigClassRegistEmail;

SWIGINTERN VALUE
_wrap_new_RegistEmail__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistEmail";
  FIX::RegistEmail *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistEmail *)new FIX::RegistEmail();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistEmail_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistEmail_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistEmail);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistEmail__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistEmail";
  FIX::RegistEmail *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistEmail", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistEmail", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistEmail *)new FIX::RegistEmail((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistEmail(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistEmail__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistEmail__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistEmail.new", 
    "    RegistEmail.new()\n"
    "    RegistEmail.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistEmail(FIX::RegistEmail *arg1) {
    delete arg1;
}

swig_class SwigClassStreamAsgnReqID;

SWIGINTERN VALUE
_wrap_new_StreamAsgnReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqID";
  FIX::StreamAsgnReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StreamAsgnReqID *)new FIX::StreamAsgnReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StreamAsgnReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StreamAsgnReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StreamAsgnReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StreamAsgnReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqID";
  FIX::StreamAsgnReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StreamAsgnReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StreamAsgnReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StreamAsgnReqID *)new FIX::StreamAsgnReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamAsgnReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StreamAsgnReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StreamAsgnReqID.new", 
    "    StreamAsgnReqID.new()\n"
    "    StreamAsgnReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnReqID(FIX::StreamAsgnReqID *arg1) {
    delete arg1;
}

swig_class SwigClassCPProgram;

SWIGINTERN VALUE
_wrap_new_CPProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CPProgram";
  FIX::CPProgram *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CPProgram *)new FIX::CPProgram();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CPProgram_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CPProgram_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CPProgram);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CPProgram__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CPProgram";
  FIX::CPProgram *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CPProgram", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CPProgram", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CPProgram *)new FIX::CPProgram((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CPProgram(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CPProgram__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CPProgram__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CPProgram.new", 
    "    CPProgram.new()\n"
    "    CPProgram.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CPProgram(FIX::CPProgram *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmReqID;

SWIGINTERN VALUE
_wrap_new_ConfirmReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmReqID";
  FIX::ConfirmReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmReqID *)new FIX::ConfirmReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmReqID";
  FIX::ConfirmReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ConfirmReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ConfirmReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ConfirmReqID *)new FIX::ConfirmReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmReqID.new", 
    "    ConfirmReqID.new()\n"
    "    ConfirmReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmReqID(FIX::ConfirmReqID *arg1) {
    delete arg1;
}

swig_class SwigClassAltMDSourceID;

SWIGINTERN VALUE
_wrap_new_AltMDSourceID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AltMDSourceID";
  FIX::AltMDSourceID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AltMDSourceID *)new FIX::AltMDSourceID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AltMDSourceID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AltMDSourceID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AltMDSourceID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AltMDSourceID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AltMDSourceID";
  FIX::AltMDSourceID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AltMDSourceID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AltMDSourceID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AltMDSourceID *)new FIX::AltMDSourceID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AltMDSourceID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AltMDSourceID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AltMDSourceID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AltMDSourceID.new", 
    "    AltMDSourceID.new()\n"
    "    AltMDSourceID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AltMDSourceID(FIX::AltMDSourceID *arg1) {
    delete arg1;
}

swig_class SwigClassNoOrders;

SWIGINTERN VALUE
_wrap_new_NoOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoOrders";
  FIX::NoOrders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoOrders *)new FIX::NoOrders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoOrders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoOrders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoOrders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoOrders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOrders";
  FIX::NoOrders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoOrders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoOrders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoOrders *)new FIX::NoOrders((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoOrders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoOrders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOrders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoOrders.new", 
    "    NoOrders.new()\n"
    "    NoOrders.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOrders(FIX::NoOrders *arg1) {
    delete arg1;
}

swig_class SwigClassCashDistribAgentAcctName;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentAcctName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctName";
  FIX::CashDistribAgentAcctName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashDistribAgentAcctName *)new FIX::CashDistribAgentAcctName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashDistribAgentAcctName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashDistribAgentAcctName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashDistribAgentAcctName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashDistribAgentAcctName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctName";
  FIX::CashDistribAgentAcctName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashDistribAgentAcctName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashDistribAgentAcctName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashDistribAgentAcctName *)new FIX::CashDistribAgentAcctName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashDistribAgentAcctName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashDistribAgentAcctName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentAcctName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashDistribAgentAcctName.new", 
    "    CashDistribAgentAcctName.new()\n"
    "    CashDistribAgentAcctName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentAcctName(FIX::CashDistribAgentAcctName *arg1) {
    delete arg1;
}

swig_class SwigClassUndlyInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyIDSource";
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UndlyInstrumentPartyIDSource *)new FIX::UndlyInstrumentPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UndlyInstrumentPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UndlyInstrumentPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyIDSource";
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::UndlyInstrumentPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::UndlyInstrumentPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::UndlyInstrumentPartyIDSource *)new FIX::UndlyInstrumentPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UndlyInstrumentPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UndlyInstrumentPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UndlyInstrumentPartyIDSource.new", 
    "    UndlyInstrumentPartyIDSource.new()\n"
    "    UndlyInstrumentPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartyIDSource(FIX::UndlyInstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSettlMethod;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlMethod";
  FIX::UnderlyingSettlMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSettlMethod *)new FIX::UnderlyingSettlMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSettlMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSettlMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSettlMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlMethod";
  FIX::UnderlyingSettlMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSettlMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSettlMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSettlMethod *)new FIX::UnderlyingSettlMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSettlMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSettlMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSettlMethod.new", 
    "    UnderlyingSettlMethod.new()\n"
    "    UnderlyingSettlMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlMethod(FIX::UnderlyingSettlMethod *arg1) {
    delete arg1;
}

swig_class SwigClassNoMDEntryTypes;

SWIGINTERN VALUE
_wrap_new_NoMDEntryTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntryTypes";
  FIX::NoMDEntryTypes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMDEntryTypes *)new FIX::NoMDEntryTypes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMDEntryTypes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMDEntryTypes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMDEntryTypes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMDEntryTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntryTypes";
  FIX::NoMDEntryTypes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMDEntryTypes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMDEntryTypes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMDEntryTypes *)new FIX::NoMDEntryTypes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMDEntryTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMDEntryTypes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMDEntryTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMDEntryTypes.new", 
    "    NoMDEntryTypes.new()\n"
    "    NoMDEntryTypes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMDEntryTypes(FIX::NoMDEntryTypes *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryForwardPoints;

SWIGINTERN VALUE
_wrap_new_MDEntryForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryForwardPoints";
  FIX::MDEntryForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryForwardPoints *)new FIX::MDEntryForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryForwardPoints";
  FIX::MDEntryForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::MDEntryForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::MDEntryForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::MDEntryForwardPoints *)new FIX::MDEntryForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryForwardPoints.new", 
    "    MDEntryForwardPoints.new()\n"
    "    MDEntryForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryForwardPoints(FIX::MDEntryForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassPosReqType;

SWIGINTERN VALUE
_wrap_new_PosReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosReqType";
  FIX::PosReqType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosReqType *)new FIX::PosReqType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosReqType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosReqType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosReqType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosReqType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqType";
  FIX::PosReqType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosReqType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosReqType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosReqType *)new FIX::PosReqType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosReqType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosReqType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosReqType.new", 
    "    PosReqType.new()\n"
    "    PosReqType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqType(FIX::PosReqType *arg1) {
    delete arg1;
}

swig_class SwigClassMassStatusReqType;

SWIGINTERN VALUE
_wrap_new_MassStatusReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqType";
  FIX::MassStatusReqType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassStatusReqType *)new FIX::MassStatusReqType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassStatusReqType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassStatusReqType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassStatusReqType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassStatusReqType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqType";
  FIX::MassStatusReqType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MassStatusReqType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MassStatusReqType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MassStatusReqType *)new FIX::MassStatusReqType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassStatusReqType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassStatusReqType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassStatusReqType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassStatusReqType.new", 
    "    MassStatusReqType.new()\n"
    "    MassStatusReqType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassStatusReqType(FIX::MassStatusReqType *arg1) {
    delete arg1;
}

swig_class SwigClassTradeOriginationDate;

SWIGINTERN VALUE
_wrap_new_TradeOriginationDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeOriginationDate";
  FIX::TradeOriginationDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeOriginationDate *)new FIX::TradeOriginationDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeOriginationDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeOriginationDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeOriginationDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeOriginationDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeOriginationDate";
  FIX::TradeOriginationDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::TradeOriginationDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::TradeOriginationDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::TradeOriginationDate *)new FIX::TradeOriginationDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeOriginationDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeOriginationDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeOriginationDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeOriginationDate.new", 
    "    TradeOriginationDate.new()\n"
    "    TradeOriginationDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeOriginationDate(FIX::TradeOriginationDate *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPrice;

SWIGINTERN VALUE
_wrap_new_SettlPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPrice";
  FIX::SettlPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPrice *)new FIX::SettlPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPrice";
  FIX::SettlPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::SettlPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::SettlPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::SettlPrice *)new FIX::SettlPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPrice.new", 
    "    SettlPrice.new()\n"
    "    SettlPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPrice(FIX::SettlPrice *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySettlAgentAcctName;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentAcctName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctName";
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySettlAgentAcctName *)new FIX::SecuritySettlAgentAcctName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySettlAgentAcctName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySettlAgentAcctName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySettlAgentAcctName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentAcctName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctName";
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySettlAgentAcctName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySettlAgentAcctName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySettlAgentAcctName *)new FIX::SecuritySettlAgentAcctName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySettlAgentAcctName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySettlAgentAcctName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentAcctName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySettlAgentAcctName.new", 
    "    SecuritySettlAgentAcctName.new()\n"
    "    SecuritySettlAgentAcctName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentAcctName(FIX::SecuritySettlAgentAcctName *arg1) {
    delete arg1;
}

swig_class SwigClassNoDerivativeEvents;

SWIGINTERN VALUE
_wrap_new_NoDerivativeEvents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeEvents";
  FIX::NoDerivativeEvents *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDerivativeEvents *)new FIX::NoDerivativeEvents();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDerivativeEvents_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDerivativeEvents_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDerivativeEvents);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDerivativeEvents__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeEvents";
  FIX::NoDerivativeEvents *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDerivativeEvents", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDerivativeEvents", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDerivativeEvents *)new FIX::NoDerivativeEvents((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDerivativeEvents(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDerivativeEvents__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeEvents__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDerivativeEvents.new", 
    "    NoDerivativeEvents.new()\n"
    "    NoDerivativeEvents.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeEvents(FIX::NoDerivativeEvents *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingEndPrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingEndPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndPrice";
  FIX::UnderlyingEndPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingEndPrice *)new FIX::UnderlyingEndPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingEndPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingEndPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingEndPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingEndPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndPrice";
  FIX::UnderlyingEndPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingEndPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingEndPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingEndPrice *)new FIX::UnderlyingEndPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingEndPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingEndPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingEndPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingEndPrice.new", 
    "    UnderlyingEndPrice.new()\n"
    "    UnderlyingEndPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingEndPrice(FIX::UnderlyingEndPrice *arg1) {
    delete arg1;
}

swig_class SwigClassSubscriptionRequestType;

SWIGINTERN VALUE
_wrap_new_SubscriptionRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SubscriptionRequestType";
  FIX::SubscriptionRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SubscriptionRequestType *)new FIX::SubscriptionRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SubscriptionRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SubscriptionRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SubscriptionRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SubscriptionRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SubscriptionRequestType";
  FIX::SubscriptionRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SubscriptionRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SubscriptionRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SubscriptionRequestType *)new FIX::SubscriptionRequestType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SubscriptionRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SubscriptionRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SubscriptionRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SubscriptionRequestType.new", 
    "    SubscriptionRequestType.new()\n"
    "    SubscriptionRequestType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SubscriptionRequestType(FIX::SubscriptionRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassTotalNumSecurityTypes;

SWIGINTERN VALUE
_wrap_new_TotalNumSecurityTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurityTypes";
  FIX::TotalNumSecurityTypes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalNumSecurityTypes *)new FIX::TotalNumSecurityTypes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalNumSecurityTypes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalNumSecurityTypes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalNumSecurityTypes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalNumSecurityTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurityTypes";
  FIX::TotalNumSecurityTypes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotalNumSecurityTypes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotalNumSecurityTypes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotalNumSecurityTypes *)new FIX::TotalNumSecurityTypes((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalNumSecurityTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalNumSecurityTypes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNumSecurityTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalNumSecurityTypes.new", 
    "    TotalNumSecurityTypes.new()\n"
    "    TotalNumSecurityTypes.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNumSecurityTypes(FIX::TotalNumSecurityTypes *arg1) {
    delete arg1;
}

swig_class SwigClassNewsCategory;

SWIGINTERN VALUE
_wrap_new_NewsCategory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NewsCategory";
  FIX::NewsCategory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NewsCategory *)new FIX::NewsCategory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NewsCategory_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NewsCategory_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NewsCategory);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NewsCategory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsCategory";
  FIX::NewsCategory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NewsCategory", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NewsCategory", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NewsCategory *)new FIX::NewsCategory((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NewsCategory(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NewsCategory__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsCategory__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NewsCategory.new", 
    "    NewsCategory.new()\n"
    "    NewsCategory.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsCategory(FIX::NewsCategory *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegPutOrCall;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegPutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegPutOrCall";
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegPutOrCall *)new FIX::UnderlyingLegPutOrCall();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegPutOrCall_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegPutOrCall_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegPutOrCall);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegPutOrCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegPutOrCall";
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingLegPutOrCall", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingLegPutOrCall", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingLegPutOrCall *)new FIX::UnderlyingLegPutOrCall((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegPutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegPutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegPutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegPutOrCall.new", 
    "    UnderlyingLegPutOrCall.new()\n"
    "    UnderlyingLegPutOrCall.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegPutOrCall(FIX::UnderlyingLegPutOrCall *arg1) {
    delete arg1;
}

swig_class SwigClassURLLink;

SWIGINTERN VALUE
_wrap_new_URLLink__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::URLLink";
  FIX::URLLink *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::URLLink *)new FIX::URLLink();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_URLLink_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_URLLink_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__URLLink);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_URLLink__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::URLLink";
  FIX::URLLink *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::URLLink", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::URLLink", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::URLLink *)new FIX::URLLink((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_URLLink(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_URLLink__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_URLLink__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "URLLink.new", 
    "    URLLink.new()\n"
    "    URLLink.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_URLLink(FIX::URLLink *arg1) {
    delete arg1;
}

swig_class SwigClassNoInstrumentPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoInstrumentPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentPartySubIDs";
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoInstrumentPartySubIDs *)new FIX::NoInstrumentPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoInstrumentPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoInstrumentPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoInstrumentPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoInstrumentPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentPartySubIDs";
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoInstrumentPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoInstrumentPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoInstrumentPartySubIDs *)new FIX::NoInstrumentPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoInstrumentPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoInstrumentPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoInstrumentPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoInstrumentPartySubIDs.new", 
    "    NoInstrumentPartySubIDs.new()\n"
    "    NoInstrumentPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoInstrumentPartySubIDs(FIX::NoInstrumentPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCurrentValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingCurrentValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrentValue";
  FIX::UnderlyingCurrentValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCurrentValue *)new FIX::UnderlyingCurrentValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCurrentValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCurrentValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCurrentValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCurrentValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrentValue";
  FIX::UnderlyingCurrentValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingCurrentValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingCurrentValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingCurrentValue *)new FIX::UnderlyingCurrentValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCurrentValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCurrentValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCurrentValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCurrentValue.new", 
    "    UnderlyingCurrentValue.new()\n"
    "    UnderlyingCurrentValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCurrentValue(FIX::UnderlyingCurrentValue *arg1) {
    delete arg1;
}

swig_class SwigClassInterestAccrualDate;

SWIGINTERN VALUE
_wrap_new_InterestAccrualDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InterestAccrualDate";
  FIX::InterestAccrualDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InterestAccrualDate *)new FIX::InterestAccrualDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InterestAccrualDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InterestAccrualDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InterestAccrualDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InterestAccrualDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InterestAccrualDate";
  FIX::InterestAccrualDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::InterestAccrualDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::InterestAccrualDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::InterestAccrualDate *)new FIX::InterestAccrualDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InterestAccrualDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InterestAccrualDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InterestAccrualDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InterestAccrualDate.new", 
    "    InterestAccrualDate.new()\n"
    "    InterestAccrualDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InterestAccrualDate(FIX::InterestAccrualDate *arg1) {
    delete arg1;
}

swig_class SwigClassFutSettDate2;

SWIGINTERN VALUE
_wrap_new_FutSettDate2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate2";
  FIX::FutSettDate2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FutSettDate2 *)new FIX::FutSettDate2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FutSettDate2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FutSettDate2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FutSettDate2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FutSettDate2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate2";
  FIX::FutSettDate2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::FutSettDate2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::FutSettDate2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::FutSettDate2 *)new FIX::FutSettDate2((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FutSettDate2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FutSettDate2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FutSettDate2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FutSettDate2.new", 
    "    FutSettDate2.new()\n"
    "    FutSettDate2.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FutSettDate2(FIX::FutSettDate2 *arg1) {
    delete arg1;
}

swig_class SwigClassNoClearingInstructions;

SWIGINTERN VALUE
_wrap_new_NoClearingInstructions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoClearingInstructions";
  FIX::NoClearingInstructions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoClearingInstructions *)new FIX::NoClearingInstructions();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoClearingInstructions_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoClearingInstructions_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoClearingInstructions);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoClearingInstructions__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoClearingInstructions";
  FIX::NoClearingInstructions *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoClearingInstructions", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoClearingInstructions", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoClearingInstructions *)new FIX::NoClearingInstructions((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoClearingInstructions(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoClearingInstructions__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoClearingInstructions__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoClearingInstructions.new", 
    "    NoClearingInstructions.new()\n"
    "    NoClearingInstructions.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoClearingInstructions(FIX::NoClearingInstructions *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCurrency;

SWIGINTERN VALUE
_wrap_new_UnderlyingCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrency";
  FIX::UnderlyingCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCurrency *)new FIX::UnderlyingCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrency";
  FIX::UnderlyingCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::UnderlyingCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::UnderlyingCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::UnderlyingCurrency *)new FIX::UnderlyingCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCurrency.new", 
    "    UnderlyingCurrency.new()\n"
    "    UnderlyingCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCurrency(FIX::UnderlyingCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassLegInterestAccrualDate;

SWIGINTERN VALUE
_wrap_new_LegInterestAccrualDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegInterestAccrualDate";
  FIX::LegInterestAccrualDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegInterestAccrualDate *)new FIX::LegInterestAccrualDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegInterestAccrualDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegInterestAccrualDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegInterestAccrualDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegInterestAccrualDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegInterestAccrualDate";
  FIX::LegInterestAccrualDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegInterestAccrualDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegInterestAccrualDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegInterestAccrualDate *)new FIX::LegInterestAccrualDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegInterestAccrualDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegInterestAccrualDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegInterestAccrualDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegInterestAccrualDate.new", 
    "    LegInterestAccrualDate.new()\n"
    "    LegInterestAccrualDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegInterestAccrualDate(FIX::LegInterestAccrualDate *arg1) {
    delete arg1;
}

swig_class SwigClassNewPassword;

SWIGINTERN VALUE
_wrap_new_NewPassword__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NewPassword";
  FIX::NewPassword *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NewPassword *)new FIX::NewPassword();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NewPassword_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NewPassword_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NewPassword);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NewPassword__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewPassword";
  FIX::NewPassword *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NewPassword", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NewPassword", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NewPassword *)new FIX::NewPassword((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NewPassword(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NewPassword__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewPassword__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NewPassword.new", 
    "    NewPassword.new()\n"
    "    NewPassword.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NewPassword(FIX::NewPassword *arg1) {
    delete arg1;
}

swig_class SwigClassRedemptionDate;

SWIGINTERN VALUE
_wrap_new_RedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RedemptionDate";
  FIX::RedemptionDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RedemptionDate *)new FIX::RedemptionDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RedemptionDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RedemptionDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RedemptionDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RedemptionDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RedemptionDate";
  FIX::RedemptionDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::RedemptionDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::RedemptionDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::RedemptionDate *)new FIX::RedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RedemptionDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RedemptionDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RedemptionDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RedemptionDate.new", 
    "    RedemptionDate.new()\n"
    "    RedemptionDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RedemptionDate(FIX::RedemptionDate *arg1) {
    delete arg1;
}

swig_class SwigClassRefApplLastSeqNum;

SWIGINTERN VALUE
_wrap_new_RefApplLastSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefApplLastSeqNum";
  FIX::RefApplLastSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefApplLastSeqNum *)new FIX::RefApplLastSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefApplLastSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefApplLastSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefApplLastSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefApplLastSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplLastSeqNum";
  FIX::RefApplLastSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::RefApplLastSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::RefApplLastSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::RefApplLastSeqNum *)new FIX::RefApplLastSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefApplLastSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefApplLastSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplLastSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefApplLastSeqNum.new", 
    "    RefApplLastSeqNum.new()\n"
    "    RefApplLastSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplLastSeqNum(FIX::RefApplLastSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassStartCash;

SWIGINTERN VALUE
_wrap_new_StartCash__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StartCash";
  FIX::StartCash *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StartCash *)new FIX::StartCash();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StartCash_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StartCash_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StartCash);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StartCash__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartCash";
  FIX::StartCash *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::StartCash", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::StartCash", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::StartCash *)new FIX::StartCash((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StartCash(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StartCash__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartCash__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StartCash.new", 
    "    StartCash.new()\n"
    "    StartCash.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StartCash(FIX::StartCash *arg1) {
    delete arg1;
}

swig_class SwigClassMaxMessageSize;

SWIGINTERN VALUE
_wrap_new_MaxMessageSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaxMessageSize";
  FIX::MaxMessageSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaxMessageSize *)new FIX::MaxMessageSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaxMessageSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaxMessageSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaxMessageSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaxMessageSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxMessageSize";
  FIX::MaxMessageSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::MaxMessageSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::MaxMessageSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::MaxMessageSize *)new FIX::MaxMessageSize((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaxMessageSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaxMessageSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxMessageSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaxMessageSize.new", 
    "    MaxMessageSize.new()\n"
    "    MaxMessageSize.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxMessageSize(FIX::MaxMessageSize *arg1) {
    delete arg1;
}

swig_class SwigClassOfferForwardPoints;

SWIGINTERN VALUE
_wrap_new_OfferForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints";
  FIX::OfferForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferForwardPoints *)new FIX::OfferForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints";
  FIX::OfferForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::OfferForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::OfferForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::OfferForwardPoints *)new FIX::OfferForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferForwardPoints.new", 
    "    OfferForwardPoints.new()\n"
    "    OfferForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferForwardPoints(FIX::OfferForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassIOIQty;

SWIGINTERN VALUE
_wrap_new_IOIQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIQty";
  FIX::IOIQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIQty *)new FIX::IOIQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQty";
  FIX::IOIQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IOIQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IOIQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IOIQty *)new FIX::IOIQty((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIQty.new", 
    "    IOIQty.new()\n"
    "    IOIQty.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIQty(FIX::IOIQty *arg1) {
    delete arg1;
}

swig_class SwigClassLastQty;

SWIGINTERN VALUE
_wrap_new_LastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastQty";
  FIX::LastQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastQty *)new FIX::LastQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastQty";
  FIX::LastQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LastQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LastQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LastQty *)new FIX::LastQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastQty.new", 
    "    LastQty.new()\n"
    "    LastQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastQty(FIX::LastQty *arg1) {
    delete arg1;
}

swig_class SwigClassApplResponseError;

SWIGINTERN VALUE
_wrap_new_ApplResponseError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseError";
  FIX::ApplResponseError *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplResponseError *)new FIX::ApplResponseError();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplResponseError_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplResponseError_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplResponseError);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplResponseError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseError";
  FIX::ApplResponseError *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplResponseError", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplResponseError", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplResponseError *)new FIX::ApplResponseError((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplResponseError(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplResponseError__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResponseError__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplResponseError.new", 
    "    ApplResponseError.new()\n"
    "    ApplResponseError.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResponseError(FIX::ApplResponseError *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityType;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityType";
  FIX::UnderlyingLegSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityType *)new FIX::UnderlyingLegSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityType";
  FIX::UnderlyingLegSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityType *)new FIX::UnderlyingLegSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityType.new", 
    "    UnderlyingLegSecurityType.new()\n"
    "    UnderlyingLegSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityType(FIX::UnderlyingLegSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativePriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_DerivativePriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasure";
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativePriceUnitOfMeasure *)new FIX::DerivativePriceUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativePriceUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativePriceUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativePriceUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasure";
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativePriceUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativePriceUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativePriceUnitOfMeasure *)new FIX::DerivativePriceUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativePriceUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativePriceUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePriceUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativePriceUnitOfMeasure.new", 
    "    DerivativePriceUnitOfMeasure.new()\n"
    "    DerivativePriceUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePriceUnitOfMeasure(FIX::DerivativePriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerPriceDirection;

SWIGINTERN VALUE
_wrap_new_TriggerPriceDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceDirection";
  FIX::TriggerPriceDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerPriceDirection *)new FIX::TriggerPriceDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerPriceDirection_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerPriceDirection_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerPriceDirection);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerPriceDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceDirection";
  FIX::TriggerPriceDirection *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TriggerPriceDirection", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TriggerPriceDirection", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TriggerPriceDirection *)new FIX::TriggerPriceDirection((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerPriceDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerPriceDirection__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPriceDirection__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerPriceDirection.new", 
    "    TriggerPriceDirection.new()\n"
    "    TriggerPriceDirection.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPriceDirection(FIX::TriggerPriceDirection *arg1) {
    delete arg1;
}

swig_class SwigClassPositionCurrency;

SWIGINTERN VALUE
_wrap_new_PositionCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PositionCurrency";
  FIX::PositionCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PositionCurrency *)new FIX::PositionCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PositionCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PositionCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PositionCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PositionCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionCurrency";
  FIX::PositionCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PositionCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PositionCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PositionCurrency *)new FIX::PositionCurrency((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PositionCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PositionCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PositionCurrency.new", 
    "    PositionCurrency.new()\n"
    "    PositionCurrency.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PositionCurrency(FIX::PositionCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassMessageEventSource;

SWIGINTERN VALUE
_wrap_new_MessageEventSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MessageEventSource";
  FIX::MessageEventSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MessageEventSource *)new FIX::MessageEventSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MessageEventSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MessageEventSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MessageEventSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MessageEventSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageEventSource";
  FIX::MessageEventSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MessageEventSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MessageEventSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MessageEventSource *)new FIX::MessageEventSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MessageEventSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MessageEventSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MessageEventSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MessageEventSource.new", 
    "    MessageEventSource.new()\n"
    "    MessageEventSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageEventSource(FIX::MessageEventSource *arg1) {
    delete arg1;
}

swig_class SwigClassCollInquiryID;

SWIGINTERN VALUE
_wrap_new_CollInquiryID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryID";
  FIX::CollInquiryID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollInquiryID *)new FIX::CollInquiryID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollInquiryID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollInquiryID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollInquiryID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollInquiryID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryID";
  FIX::CollInquiryID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CollInquiryID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CollInquiryID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CollInquiryID *)new FIX::CollInquiryID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollInquiryID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollInquiryID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollInquiryID.new", 
    "    CollInquiryID.new()\n"
    "    CollInquiryID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryID(FIX::CollInquiryID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingStartValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingStartValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStartValue";
  FIX::UnderlyingStartValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingStartValue *)new FIX::UnderlyingStartValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingStartValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingStartValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingStartValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingStartValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStartValue";
  FIX::UnderlyingStartValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingStartValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingStartValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingStartValue *)new FIX::UnderlyingStartValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingStartValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingStartValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStartValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingStartValue.new", 
    "    UnderlyingStartValue.new()\n"
    "    UnderlyingStartValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStartValue(FIX::UnderlyingStartValue *arg1) {
    delete arg1;
}

swig_class SwigClassLastLiquidityInd;

SWIGINTERN VALUE
_wrap_new_LastLiquidityInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastLiquidityInd";
  FIX::LastLiquidityInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastLiquidityInd *)new FIX::LastLiquidityInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastLiquidityInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastLiquidityInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastLiquidityInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastLiquidityInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastLiquidityInd";
  FIX::LastLiquidityInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LastLiquidityInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LastLiquidityInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LastLiquidityInd *)new FIX::LastLiquidityInd((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastLiquidityInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastLiquidityInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastLiquidityInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastLiquidityInd.new", 
    "    LastLiquidityInd.new()\n"
    "    LastLiquidityInd.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastLiquidityInd(FIX::LastLiquidityInd *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityID;

SWIGINTERN VALUE
_wrap_new_SecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityID";
  FIX::SecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityID *)new FIX::SecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityID";
  FIX::SecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityID *)new FIX::SecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityID.new", 
    "    SecurityID.new()\n"
    "    SecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityID(FIX::SecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassNoMDEntries;

SWIGINTERN VALUE
_wrap_new_NoMDEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntries";
  FIX::NoMDEntries *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMDEntries *)new FIX::NoMDEntries();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMDEntries_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMDEntries_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMDEntries);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMDEntries__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntries";
  FIX::NoMDEntries *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMDEntries", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMDEntries", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMDEntries *)new FIX::NoMDEntries((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMDEntries(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMDEntries__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMDEntries__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMDEntries.new", 
    "    NoMDEntries.new()\n"
    "    NoMDEntries.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMDEntries(FIX::NoMDEntries *arg1) {
    delete arg1;
}

swig_class SwigClassStrikePriceDeterminationMethod;

SWIGINTERN VALUE
_wrap_new_StrikePriceDeterminationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceDeterminationMethod";
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikePriceDeterminationMethod *)new FIX::StrikePriceDeterminationMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikePriceDeterminationMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikePriceDeterminationMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikePriceDeterminationMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikePriceDeterminationMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceDeterminationMethod";
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StrikePriceDeterminationMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StrikePriceDeterminationMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StrikePriceDeterminationMethod *)new FIX::StrikePriceDeterminationMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikePriceDeterminationMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikePriceDeterminationMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePriceDeterminationMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikePriceDeterminationMethod.new", 
    "    StrikePriceDeterminationMethod.new()\n"
    "    StrikePriceDeterminationMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePriceDeterminationMethod(FIX::StrikePriceDeterminationMethod *arg1) {
    delete arg1;
}

swig_class SwigClassEndDate;

SWIGINTERN VALUE
_wrap_new_EndDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndDate";
  FIX::EndDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndDate *)new FIX::EndDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndDate";
  FIX::EndDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::EndDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::EndDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::EndDate *)new FIX::EndDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndDate.new", 
    "    EndDate.new()\n"
    "    EndDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndDate(FIX::EndDate *arg1) {
    delete arg1;
}

swig_class SwigClassCashOutstanding;

SWIGINTERN VALUE
_wrap_new_CashOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashOutstanding";
  FIX::CashOutstanding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashOutstanding *)new FIX::CashOutstanding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashOutstanding_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashOutstanding_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashOutstanding);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashOutstanding__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashOutstanding";
  FIX::CashOutstanding *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::CashOutstanding", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::CashOutstanding", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::CashOutstanding *)new FIX::CashOutstanding((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashOutstanding(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashOutstanding__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashOutstanding__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashOutstanding.new", 
    "    CashOutstanding.new()\n"
    "    CashOutstanding.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashOutstanding(FIX::CashOutstanding *arg1) {
    delete arg1;
}

swig_class SwigClassMDReqID;

SWIGINTERN VALUE
_wrap_new_MDReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDReqID";
  FIX::MDReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDReqID *)new FIX::MDReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReqID";
  FIX::MDReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDReqID *)new FIX::MDReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDReqID.new", 
    "    MDReqID.new()\n"
    "    MDReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDReqID(FIX::MDReqID *arg1) {
    delete arg1;
}

swig_class SwigClassIOIRefID;

SWIGINTERN VALUE
_wrap_new_IOIRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIRefID";
  FIX::IOIRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIRefID *)new FIX::IOIRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIRefID";
  FIX::IOIRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IOIRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IOIRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IOIRefID *)new FIX::IOIRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIRefID.new", 
    "    IOIRefID.new()\n"
    "    IOIRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIRefID(FIX::IOIRefID *arg1) {
    delete arg1;
}

swig_class SwigClassTargetStrategy;

SWIGINTERN VALUE
_wrap_new_TargetStrategy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategy";
  FIX::TargetStrategy *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetStrategy *)new FIX::TargetStrategy();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetStrategy_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetStrategy_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetStrategy);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetStrategy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategy";
  FIX::TargetStrategy *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TargetStrategy", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TargetStrategy", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TargetStrategy *)new FIX::TargetStrategy((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetStrategy(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetStrategy__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetStrategy__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetStrategy.new", 
    "    TargetStrategy.new()\n"
    "    TargetStrategy.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetStrategy(FIX::TargetStrategy *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmRefID;

SWIGINTERN VALUE
_wrap_new_ConfirmRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRefID";
  FIX::ConfirmRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmRefID *)new FIX::ConfirmRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRefID";
  FIX::ConfirmRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ConfirmRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ConfirmRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ConfirmRefID *)new FIX::ConfirmRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmRefID.new", 
    "    ConfirmRefID.new()\n"
    "    ConfirmRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmRefID(FIX::ConfirmRefID *arg1) {
    delete arg1;
}

swig_class SwigClassSellerDays;

SWIGINTERN VALUE
_wrap_new_SellerDays__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SellerDays";
  FIX::SellerDays *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SellerDays *)new FIX::SellerDays();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SellerDays_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SellerDays_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SellerDays);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SellerDays__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SellerDays";
  FIX::SellerDays *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SellerDays", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SellerDays", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SellerDays *)new FIX::SellerDays((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SellerDays(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SellerDays__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SellerDays__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SellerDays.new", 
    "    SellerDays.new()\n"
    "    SellerDays.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SellerDays(FIX::SellerDays *arg1) {
    delete arg1;
}

swig_class SwigClassDueToRelated;

SWIGINTERN VALUE
_wrap_new_DueToRelated__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DueToRelated";
  FIX::DueToRelated *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DueToRelated *)new FIX::DueToRelated();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DueToRelated_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DueToRelated_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DueToRelated);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DueToRelated__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DueToRelated";
  FIX::DueToRelated *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::DueToRelated", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::DueToRelated", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::DueToRelated *)new FIX::DueToRelated((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DueToRelated(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DueToRelated__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DueToRelated__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DueToRelated.new", 
    "    DueToRelated.new()\n"
    "    DueToRelated.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DueToRelated(FIX::DueToRelated *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryTradingReferencePrice;

SWIGINTERN VALUE
_wrap_new_SecondaryTradingReferencePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradingReferencePrice";
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryTradingReferencePrice *)new FIX::SecondaryTradingReferencePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryTradingReferencePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryTradingReferencePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryTradingReferencePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryTradingReferencePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradingReferencePrice";
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::SecondaryTradingReferencePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::SecondaryTradingReferencePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::SecondaryTradingReferencePrice *)new FIX::SecondaryTradingReferencePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryTradingReferencePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryTradingReferencePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradingReferencePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryTradingReferencePrice.new", 
    "    SecondaryTradingReferencePrice.new()\n"
    "    SecondaryTradingReferencePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradingReferencePrice(FIX::SecondaryTradingReferencePrice *arg1) {
    delete arg1;
}

swig_class SwigClassNoMDFeedTypes;

SWIGINTERN VALUE
_wrap_new_NoMDFeedTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMDFeedTypes";
  FIX::NoMDFeedTypes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMDFeedTypes *)new FIX::NoMDFeedTypes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMDFeedTypes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMDFeedTypes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMDFeedTypes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMDFeedTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDFeedTypes";
  FIX::NoMDFeedTypes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMDFeedTypes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMDFeedTypes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMDFeedTypes *)new FIX::NoMDFeedTypes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMDFeedTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMDFeedTypes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMDFeedTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMDFeedTypes.new", 
    "    NoMDFeedTypes.new()\n"
    "    NoMDFeedTypes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMDFeedTypes(FIX::NoMDFeedTypes *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubIDType";
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingInstrumentPartySubIDType *)new FIX::UnderlyingInstrumentPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingInstrumentPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingInstrumentPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubIDType";
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingInstrumentPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingInstrumentPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingInstrumentPartySubIDType *)new FIX::UnderlyingInstrumentPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingInstrumentPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingInstrumentPartySubIDType.new", 
    "    UnderlyingInstrumentPartySubIDType.new()\n"
    "    UnderlyingInstrumentPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartySubIDType(FIX::UnderlyingInstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesCloseTime;

SWIGINTERN VALUE
_wrap_new_TradSesCloseTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  FIX::TradSesCloseTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesCloseTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  FIX::TradSesCloseTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TradSesCloseTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesCloseTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  FIX::TradSesCloseTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesCloseTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesCloseTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesCloseTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesCloseTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesCloseTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesCloseTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  FIX::TradSesCloseTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesCloseTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesCloseTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TradSesCloseTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesCloseTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesCloseTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesCloseTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TradSesCloseTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesCloseTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TradSesCloseTime.new", 
    "    TradSesCloseTime.new()\n"
    "    TradSesCloseTime.new(bool showMilliseconds)\n"
    "    TradSesCloseTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TradSesCloseTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesCloseTime(FIX::TradSesCloseTime *arg1) {
    delete arg1;
}

swig_class SwigClassContractSettlMonth;

SWIGINTERN VALUE
_wrap_new_ContractSettlMonth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContractSettlMonth";
  FIX::ContractSettlMonth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContractSettlMonth *)new FIX::ContractSettlMonth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContractSettlMonth_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContractSettlMonth_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContractSettlMonth);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContractSettlMonth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractSettlMonth";
  FIX::ContractSettlMonth *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::ContractSettlMonth", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::ContractSettlMonth", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::ContractSettlMonth *)new FIX::ContractSettlMonth((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContractSettlMonth(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContractSettlMonth__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContractSettlMonth__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContractSettlMonth.new", 
    "    ContractSettlMonth.new()\n"
    "    ContractSettlMonth.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContractSettlMonth(FIX::ContractSettlMonth *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeStrikePrice;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikePrice";
  FIX::DerivativeStrikePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeStrikePrice *)new FIX::DerivativeStrikePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeStrikePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeStrikePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeStrikePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeStrikePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikePrice";
  FIX::DerivativeStrikePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::DerivativeStrikePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::DerivativeStrikePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::DerivativeStrikePrice *)new FIX::DerivativeStrikePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeStrikePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeStrikePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeStrikePrice.new", 
    "    DerivativeStrikePrice.new()\n"
    "    DerivativeStrikePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikePrice(FIX::DerivativeStrikePrice *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerSecurityDesc;

SWIGINTERN VALUE
_wrap_new_TriggerSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityDesc";
  FIX::TriggerSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerSecurityDesc *)new FIX::TriggerSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityDesc";
  FIX::TriggerSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TriggerSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TriggerSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TriggerSecurityDesc *)new FIX::TriggerSecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerSecurityDesc.new", 
    "    TriggerSecurityDesc.new()\n"
    "    TriggerSecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSecurityDesc(FIX::TriggerSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCashType;

SWIGINTERN VALUE
_wrap_new_UnderlyingCashType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashType";
  FIX::UnderlyingCashType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCashType *)new FIX::UnderlyingCashType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCashType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCashType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCashType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCashType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashType";
  FIX::UnderlyingCashType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingCashType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingCashType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingCashType *)new FIX::UnderlyingCashType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCashType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCashType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCashType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCashType.new", 
    "    UnderlyingCashType.new()\n"
    "    UnderlyingCashType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCashType(FIX::UnderlyingCashType *arg1) {
    delete arg1;
}

swig_class SwigClassNoMiscFees;

SWIGINTERN VALUE
_wrap_new_NoMiscFees__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMiscFees";
  FIX::NoMiscFees *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMiscFees *)new FIX::NoMiscFees();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMiscFees_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMiscFees_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMiscFees);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMiscFees__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMiscFees";
  FIX::NoMiscFees *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMiscFees", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMiscFees", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMiscFees *)new FIX::NoMiscFees((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMiscFees(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMiscFees__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMiscFees__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMiscFees.new", 
    "    NoMiscFees.new()\n"
    "    NoMiscFees.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMiscFees(FIX::NoMiscFees *arg1) {
    delete arg1;
}

swig_class SwigClassCustOrderCapacity;

SWIGINTERN VALUE
_wrap_new_CustOrderCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CustOrderCapacity";
  FIX::CustOrderCapacity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CustOrderCapacity *)new FIX::CustOrderCapacity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CustOrderCapacity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CustOrderCapacity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CustOrderCapacity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CustOrderCapacity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustOrderCapacity";
  FIX::CustOrderCapacity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CustOrderCapacity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CustOrderCapacity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CustOrderCapacity *)new FIX::CustOrderCapacity((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CustOrderCapacity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CustOrderCapacity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustOrderCapacity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CustOrderCapacity.new", 
    "    CustOrderCapacity.new()\n"
    "    CustOrderCapacity.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CustOrderCapacity(FIX::CustOrderCapacity *arg1) {
    delete arg1;
}

swig_class SwigClassLegAllocSettlCurrency;

SWIGINTERN VALUE
_wrap_new_LegAllocSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegAllocSettlCurrency";
  FIX::LegAllocSettlCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegAllocSettlCurrency *)new FIX::LegAllocSettlCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegAllocSettlCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegAllocSettlCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegAllocSettlCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegAllocSettlCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocSettlCurrency";
  FIX::LegAllocSettlCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::LegAllocSettlCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::LegAllocSettlCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::LegAllocSettlCurrency *)new FIX::LegAllocSettlCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegAllocSettlCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegAllocSettlCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocSettlCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegAllocSettlCurrency.new", 
    "    LegAllocSettlCurrency.new()\n"
    "    LegAllocSettlCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocSettlCurrency(FIX::LegAllocSettlCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingAdjustedQuantity;

SWIGINTERN VALUE
_wrap_new_UnderlyingAdjustedQuantity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAdjustedQuantity";
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingAdjustedQuantity *)new FIX::UnderlyingAdjustedQuantity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingAdjustedQuantity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingAdjustedQuantity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingAdjustedQuantity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAdjustedQuantity";
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::UnderlyingAdjustedQuantity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::UnderlyingAdjustedQuantity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::UnderlyingAdjustedQuantity *)new FIX::UnderlyingAdjustedQuantity((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingAdjustedQuantity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingAdjustedQuantity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingAdjustedQuantity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingAdjustedQuantity.new", 
    "    UnderlyingAdjustedQuantity.new()\n"
    "    UnderlyingAdjustedQuantity.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingAdjustedQuantity(FIX::UnderlyingAdjustedQuantity *arg1) {
    delete arg1;
}

swig_class SwigClassOwnershipType;

SWIGINTERN VALUE
_wrap_new_OwnershipType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OwnershipType";
  FIX::OwnershipType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OwnershipType *)new FIX::OwnershipType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OwnershipType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OwnershipType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OwnershipType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OwnershipType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OwnershipType";
  FIX::OwnershipType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OwnershipType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OwnershipType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OwnershipType *)new FIX::OwnershipType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OwnershipType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OwnershipType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OwnershipType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OwnershipType.new", 
    "    OwnershipType.new()\n"
    "    OwnershipType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OwnershipType(FIX::OwnershipType *arg1) {
    delete arg1;
}

swig_class SwigClassMaxShow;

SWIGINTERN VALUE
_wrap_new_MaxShow__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaxShow";
  FIX::MaxShow *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaxShow *)new FIX::MaxShow();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaxShow_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaxShow_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaxShow);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaxShow__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxShow";
  FIX::MaxShow *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MaxShow", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MaxShow", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MaxShow *)new FIX::MaxShow((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaxShow(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaxShow__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxShow__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaxShow.new", 
    "    MaxShow.new()\n"
    "    MaxShow.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxShow(FIX::MaxShow *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityID;

SWIGINTERN VALUE
_wrap_new_LegSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityID";
  FIX::LegSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityID *)new FIX::LegSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityID";
  FIX::LegSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecurityID *)new FIX::LegSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityID.new", 
    "    LegSecurityID.new()\n"
    "    LegSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityID(FIX::LegSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityDesc;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityDesc";
  FIX::DerivativeSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityDesc *)new FIX::DerivativeSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityDesc";
  FIX::DerivativeSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityDesc *)new FIX::DerivativeSecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityDesc.new", 
    "    DerivativeSecurityDesc.new()\n"
    "    DerivativeSecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityDesc(FIX::DerivativeSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_UnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasure";
  FIX::UnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnitOfMeasure *)new FIX::UnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasure";
  FIX::UnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnitOfMeasure *)new FIX::UnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnitOfMeasure.new", 
    "    UnitOfMeasure.new()\n"
    "    UnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnitOfMeasure(FIX::UnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassQuantity;

SWIGINTERN VALUE
_wrap_new_Quantity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Quantity";
  FIX::Quantity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Quantity *)new FIX::Quantity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Quantity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Quantity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Quantity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Quantity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Quantity";
  FIX::Quantity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::Quantity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::Quantity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::Quantity *)new FIX::Quantity((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Quantity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Quantity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Quantity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Quantity.new", 
    "    Quantity.new()\n"
    "    Quantity.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Quantity(FIX::Quantity *arg1) {
    delete arg1;
}

swig_class SwigClassNewsID;

SWIGINTERN VALUE
_wrap_new_NewsID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NewsID";
  FIX::NewsID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NewsID *)new FIX::NewsID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NewsID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NewsID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NewsID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NewsID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsID";
  FIX::NewsID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NewsID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NewsID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NewsID *)new FIX::NewsID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NewsID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NewsID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NewsID.new", 
    "    NewsID.new()\n"
    "    NewsID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsID(FIX::NewsID *arg1) {
    delete arg1;
}

swig_class SwigClassUndlyInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubIDType";
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UndlyInstrumentPartySubIDType *)new FIX::UndlyInstrumentPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UndlyInstrumentPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UndlyInstrumentPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubIDType";
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UndlyInstrumentPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UndlyInstrumentPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UndlyInstrumentPartySubIDType *)new FIX::UndlyInstrumentPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UndlyInstrumentPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UndlyInstrumentPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UndlyInstrumentPartySubIDType.new", 
    "    UndlyInstrumentPartySubIDType.new()\n"
    "    UndlyInstrumentPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartySubIDType(FIX::UndlyInstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassSettleOnOpenFlag;

SWIGINTERN VALUE
_wrap_new_SettleOnOpenFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettleOnOpenFlag";
  FIX::SettleOnOpenFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettleOnOpenFlag *)new FIX::SettleOnOpenFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettleOnOpenFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettleOnOpenFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettleOnOpenFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettleOnOpenFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettleOnOpenFlag";
  FIX::SettleOnOpenFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettleOnOpenFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettleOnOpenFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettleOnOpenFlag *)new FIX::SettleOnOpenFlag((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettleOnOpenFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettleOnOpenFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettleOnOpenFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettleOnOpenFlag.new", 
    "    SettleOnOpenFlag.new()\n"
    "    SettleOnOpenFlag.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettleOnOpenFlag(FIX::SettleOnOpenFlag *arg1) {
    delete arg1;
}

swig_class SwigClassLastUpdateTime;

SWIGINTERN VALUE
_wrap_new_LastUpdateTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  FIX::LastUpdateTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_LastUpdateTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  FIX::LastUpdateTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::LastUpdateTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_LastUpdateTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  FIX::LastUpdateTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::LastUpdateTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::LastUpdateTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastUpdateTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastUpdateTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastUpdateTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastUpdateTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  FIX::LastUpdateTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::LastUpdateTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::LastUpdateTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::LastUpdateTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastUpdateTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastUpdateTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastUpdateTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LastUpdateTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LastUpdateTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "LastUpdateTime.new", 
    "    LastUpdateTime.new()\n"
    "    LastUpdateTime.new(bool showMilliseconds)\n"
    "    LastUpdateTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    LastUpdateTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastUpdateTime(FIX::LastUpdateTime *arg1) {
    delete arg1;
}

swig_class SwigClassRepurchaseRate;

SWIGINTERN VALUE
_wrap_new_RepurchaseRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseRate";
  FIX::RepurchaseRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RepurchaseRate *)new FIX::RepurchaseRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RepurchaseRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RepurchaseRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RepurchaseRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RepurchaseRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseRate";
  FIX::RepurchaseRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::RepurchaseRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::RepurchaseRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::RepurchaseRate *)new FIX::RepurchaseRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RepurchaseRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RepurchaseRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepurchaseRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RepurchaseRate.new", 
    "    RepurchaseRate.new()\n"
    "    RepurchaseRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RepurchaseRate(FIX::RepurchaseRate *arg1) {
    delete arg1;
}

swig_class SwigClassRepurchaseTerm;

SWIGINTERN VALUE
_wrap_new_RepurchaseTerm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseTerm";
  FIX::RepurchaseTerm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RepurchaseTerm *)new FIX::RepurchaseTerm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RepurchaseTerm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RepurchaseTerm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RepurchaseTerm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RepurchaseTerm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseTerm";
  FIX::RepurchaseTerm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RepurchaseTerm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RepurchaseTerm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RepurchaseTerm *)new FIX::RepurchaseTerm((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RepurchaseTerm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RepurchaseTerm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepurchaseTerm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RepurchaseTerm.new", 
    "    RepurchaseTerm.new()\n"
    "    RepurchaseTerm.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RepurchaseTerm(FIX::RepurchaseTerm *arg1) {
    delete arg1;
}

swig_class SwigClassNestedPartyRole;

SWIGINTERN VALUE
_wrap_new_NestedPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyRole";
  FIX::NestedPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedPartyRole *)new FIX::NestedPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyRole";
  FIX::NestedPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NestedPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NestedPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NestedPartyRole *)new FIX::NestedPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedPartyRole.new", 
    "    NestedPartyRole.new()\n"
    "    NestedPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartyRole(FIX::NestedPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryExecID;

SWIGINTERN VALUE
_wrap_new_SecondaryExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryExecID";
  FIX::SecondaryExecID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryExecID *)new FIX::SecondaryExecID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryExecID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryExecID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryExecID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryExecID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryExecID";
  FIX::SecondaryExecID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryExecID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryExecID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryExecID *)new FIX::SecondaryExecID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryExecID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryExecID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryExecID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryExecID.new", 
    "    SecondaryExecID.new()\n"
    "    SecondaryExecID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryExecID(FIX::SecondaryExecID *arg1) {
    delete arg1;
}

swig_class SwigClassPool;

SWIGINTERN VALUE
_wrap_new_Pool__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Pool";
  FIX::Pool *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Pool *)new FIX::Pool();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Pool_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Pool_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Pool);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Pool__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Pool";
  FIX::Pool *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Pool", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Pool", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Pool *)new FIX::Pool((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Pool(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Pool__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Pool__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Pool.new", 
    "    Pool.new()\n"
    "    Pool.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Pool(FIX::Pool *arg1) {
    delete arg1;
}

swig_class SwigClassNoTickRules;

SWIGINTERN VALUE
_wrap_new_NoTickRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTickRules";
  FIX::NoTickRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTickRules *)new FIX::NoTickRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTickRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTickRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTickRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTickRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTickRules";
  FIX::NoTickRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTickRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTickRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTickRules *)new FIX::NoTickRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTickRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTickRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTickRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTickRules.new", 
    "    NoTickRules.new()\n"
    "    NoTickRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTickRules(FIX::NoTickRules *arg1) {
    delete arg1;
}

swig_class SwigClassVolatility;

SWIGINTERN VALUE
_wrap_new_Volatility__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Volatility";
  FIX::Volatility *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Volatility *)new FIX::Volatility();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Volatility_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Volatility_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Volatility);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Volatility__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Volatility";
  FIX::Volatility *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::Volatility", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::Volatility", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::Volatility *)new FIX::Volatility((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Volatility(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Volatility__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Volatility__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Volatility.new", 
    "    Volatility.new()\n"
    "    Volatility.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Volatility(FIX::Volatility *arg1) {
    delete arg1;
}

swig_class SwigClassPctAtRisk;

SWIGINTERN VALUE
_wrap_new_PctAtRisk__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PctAtRisk";
  FIX::PctAtRisk *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PctAtRisk *)new FIX::PctAtRisk();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PctAtRisk_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PctAtRisk_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PctAtRisk);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PctAtRisk__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PctAtRisk";
  FIX::PctAtRisk *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::PctAtRisk", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::PctAtRisk", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::PctAtRisk *)new FIX::PctAtRisk((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PctAtRisk(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PctAtRisk__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PctAtRisk__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PctAtRisk.new", 
    "    PctAtRisk.new()\n"
    "    PctAtRisk.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PctAtRisk(FIX::PctAtRisk *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityExchange;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityExchange";
  FIX::UnderlyingSecurityExchange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityExchange *)new FIX::UnderlyingSecurityExchange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityExchange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityExchange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityExchange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityExchange";
  FIX::UnderlyingSecurityExchange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::UnderlyingSecurityExchange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::UnderlyingSecurityExchange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::UnderlyingSecurityExchange *)new FIX::UnderlyingSecurityExchange((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityExchange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityExchange.new", 
    "    UnderlyingSecurityExchange.new()\n"
    "    UnderlyingSecurityExchange.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityExchange(FIX::UnderlyingSecurityExchange *arg1) {
    delete arg1;
}

swig_class SwigClassLegStrikePrice;

SWIGINTERN VALUE
_wrap_new_LegStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegStrikePrice";
  FIX::LegStrikePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegStrikePrice *)new FIX::LegStrikePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegStrikePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegStrikePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegStrikePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegStrikePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStrikePrice";
  FIX::LegStrikePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LegStrikePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LegStrikePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LegStrikePrice *)new FIX::LegStrikePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegStrikePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegStrikePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStrikePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegStrikePrice.new", 
    "    LegStrikePrice.new()\n"
    "    LegStrikePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStrikePrice(FIX::LegStrikePrice *arg1) {
    delete arg1;
}

swig_class SwigClassSettlmntTyp;

SWIGINTERN VALUE
_wrap_new_SettlmntTyp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlmntTyp";
  FIX::SettlmntTyp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlmntTyp *)new FIX::SettlmntTyp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlmntTyp_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlmntTyp_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlmntTyp);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlmntTyp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlmntTyp";
  FIX::SettlmntTyp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlmntTyp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlmntTyp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlmntTyp *)new FIX::SettlmntTyp((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlmntTyp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlmntTyp__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlmntTyp__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlmntTyp.new", 
    "    SettlmntTyp.new()\n"
    "    SettlmntTyp.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlmntTyp(FIX::SettlmntTyp *arg1) {
    delete arg1;
}

swig_class SwigClassTradePublishIndicator;

SWIGINTERN VALUE
_wrap_new_TradePublishIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradePublishIndicator";
  FIX::TradePublishIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradePublishIndicator *)new FIX::TradePublishIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradePublishIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradePublishIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradePublishIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradePublishIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradePublishIndicator";
  FIX::TradePublishIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradePublishIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradePublishIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradePublishIndicator *)new FIX::TradePublishIndicator((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradePublishIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradePublishIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradePublishIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradePublishIndicator.new", 
    "    TradePublishIndicator.new()\n"
    "    TradePublishIndicator.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradePublishIndicator(FIX::TradePublishIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassApplResponseType;

SWIGINTERN VALUE
_wrap_new_ApplResponseType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseType";
  FIX::ApplResponseType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplResponseType *)new FIX::ApplResponseType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplResponseType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplResponseType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplResponseType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplResponseType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseType";
  FIX::ApplResponseType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplResponseType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplResponseType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplResponseType *)new FIX::ApplResponseType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplResponseType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplResponseType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResponseType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplResponseType.new", 
    "    ApplResponseType.new()\n"
    "    ApplResponseType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResponseType(FIX::ApplResponseType *arg1) {
    delete arg1;
}

swig_class SwigClassMDSubBookType;

SWIGINTERN VALUE
_wrap_new_MDSubBookType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDSubBookType";
  FIX::MDSubBookType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDSubBookType *)new FIX::MDSubBookType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDSubBookType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDSubBookType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDSubBookType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDSubBookType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSubBookType";
  FIX::MDSubBookType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDSubBookType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDSubBookType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDSubBookType *)new FIX::MDSubBookType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDSubBookType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDSubBookType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDSubBookType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDSubBookType.new", 
    "    MDSubBookType.new()\n"
    "    MDSubBookType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDSubBookType(FIX::MDSubBookType *arg1) {
    delete arg1;
}

swig_class SwigClassUsername;

SWIGINTERN VALUE
_wrap_new_Username__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Username";
  FIX::Username *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Username *)new FIX::Username();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Username_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Username_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Username);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Username__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Username";
  FIX::Username *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Username", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Username", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Username *)new FIX::Username((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Username(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Username__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Username__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Username.new", 
    "    Username.new()\n"
    "    Username.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Username(FIX::Username *arg1) {
    delete arg1;
}

swig_class SwigClassStandInstDbType;

SWIGINTERN VALUE
_wrap_new_StandInstDbType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbType";
  FIX::StandInstDbType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StandInstDbType *)new FIX::StandInstDbType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StandInstDbType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StandInstDbType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StandInstDbType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StandInstDbType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbType";
  FIX::StandInstDbType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StandInstDbType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StandInstDbType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StandInstDbType *)new FIX::StandInstDbType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StandInstDbType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StandInstDbType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StandInstDbType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StandInstDbType.new", 
    "    StandInstDbType.new()\n"
    "    StandInstDbType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StandInstDbType(FIX::StandInstDbType *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteEntryStatus;

SWIGINTERN VALUE
_wrap_new_QuoteEntryStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryStatus";
  FIX::QuoteEntryStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteEntryStatus *)new FIX::QuoteEntryStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteEntryStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteEntryStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteEntryStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteEntryStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryStatus";
  FIX::QuoteEntryStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteEntryStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteEntryStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteEntryStatus *)new FIX::QuoteEntryStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteEntryStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteEntryStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteEntryStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteEntryStatus.new", 
    "    QuoteEntryStatus.new()\n"
    "    QuoteEntryStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteEntryStatus(FIX::QuoteEntryStatus *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerPriceType;

SWIGINTERN VALUE
_wrap_new_TriggerPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceType";
  FIX::TriggerPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerPriceType *)new FIX::TriggerPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceType";
  FIX::TriggerPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TriggerPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TriggerPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TriggerPriceType *)new FIX::TriggerPriceType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerPriceType.new", 
    "    TriggerPriceType.new()\n"
    "    TriggerPriceType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPriceType(FIX::TriggerPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassSideTrdSubTyp;

SWIGINTERN VALUE
_wrap_new_SideTrdSubTyp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideTrdSubTyp";
  FIX::SideTrdSubTyp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideTrdSubTyp *)new FIX::SideTrdSubTyp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideTrdSubTyp_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideTrdSubTyp_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideTrdSubTyp);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideTrdSubTyp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdSubTyp";
  FIX::SideTrdSubTyp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideTrdSubTyp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideTrdSubTyp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideTrdSubTyp *)new FIX::SideTrdSubTyp((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideTrdSubTyp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideTrdSubTyp__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdSubTyp__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideTrdSubTyp.new", 
    "    SideTrdSubTyp.new()\n"
    "    SideTrdSubTyp.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdSubTyp(FIX::SideTrdSubTyp *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingTradingSessionSubID;

SWIGINTERN VALUE
_wrap_new_UnderlyingTradingSessionSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionSubID";
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingTradingSessionSubID *)new FIX::UnderlyingTradingSessionSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingTradingSessionSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingTradingSessionSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingTradingSessionSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionSubID";
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingTradingSessionSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingTradingSessionSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingTradingSessionSubID *)new FIX::UnderlyingTradingSessionSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingTradingSessionSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingTradingSessionSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingTradingSessionSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingTradingSessionSubID.new", 
    "    UnderlyingTradingSessionSubID.new()\n"
    "    UnderlyingTradingSessionSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingTradingSessionSubID(FIX::UnderlyingTradingSessionSubID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstReqRejCode;

SWIGINTERN VALUE
_wrap_new_SettlInstReqRejCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqRejCode";
  FIX::SettlInstReqRejCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstReqRejCode *)new FIX::SettlInstReqRejCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstReqRejCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstReqRejCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstReqRejCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstReqRejCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqRejCode";
  FIX::SettlInstReqRejCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SettlInstReqRejCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SettlInstReqRejCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SettlInstReqRejCode *)new FIX::SettlInstReqRejCode((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstReqRejCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstReqRejCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstReqRejCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstReqRejCode.new", 
    "    SettlInstReqRejCode.new()\n"
    "    SettlInstReqRejCode.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstReqRejCode(FIX::SettlInstReqRejCode *arg1) {
    delete arg1;
}

swig_class SwigClassMktBidPx;

SWIGINTERN VALUE
_wrap_new_MktBidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MktBidPx";
  FIX::MktBidPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MktBidPx *)new FIX::MktBidPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MktBidPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MktBidPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MktBidPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MktBidPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MktBidPx";
  FIX::MktBidPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::MktBidPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::MktBidPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::MktBidPx *)new FIX::MktBidPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MktBidPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MktBidPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MktBidPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MktBidPx.new", 
    "    MktBidPx.new()\n"
    "    MktBidPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MktBidPx(FIX::MktBidPx *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSymbol;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbol";
  FIX::UnderlyingLegSymbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSymbol *)new FIX::UnderlyingLegSymbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSymbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSymbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSymbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbol";
  FIX::UnderlyingLegSymbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSymbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSymbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSymbol *)new FIX::UnderlyingLegSymbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSymbol.new", 
    "    UnderlyingLegSymbol.new()\n"
    "    UnderlyingLegSymbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSymbol(FIX::UnderlyingLegSymbol *arg1) {
    delete arg1;
}

swig_class SwigClassStrikeValue;

SWIGINTERN VALUE
_wrap_new_StrikeValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikeValue";
  FIX::StrikeValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikeValue *)new FIX::StrikeValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikeValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikeValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikeValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikeValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeValue";
  FIX::StrikeValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::StrikeValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::StrikeValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::StrikeValue *)new FIX::StrikeValue((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikeValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikeValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikeValue.new", 
    "    StrikeValue.new()\n"
    "    StrikeValue.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeValue(FIX::StrikeValue *arg1) {
    delete arg1;
}

swig_class SwigClassUrgency;

SWIGINTERN VALUE
_wrap_new_Urgency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Urgency";
  FIX::Urgency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Urgency *)new FIX::Urgency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Urgency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Urgency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Urgency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Urgency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Urgency";
  FIX::Urgency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Urgency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Urgency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Urgency *)new FIX::Urgency((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Urgency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Urgency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Urgency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Urgency.new", 
    "    Urgency.new()\n"
    "    Urgency.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Urgency(FIX::Urgency *arg1) {
    delete arg1;
}

swig_class SwigClassAllocID;

SWIGINTERN VALUE
_wrap_new_AllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocID";
  FIX::AllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocID *)new FIX::AllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocID";
  FIX::AllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocID *)new FIX::AllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocID.new", 
    "    AllocID.new()\n"
    "    AllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocID(FIX::AllocID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingDeliveryAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingDeliveryAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDeliveryAmount";
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingDeliveryAmount *)new FIX::UnderlyingDeliveryAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingDeliveryAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingDeliveryAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingDeliveryAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingDeliveryAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDeliveryAmount";
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingDeliveryAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingDeliveryAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingDeliveryAmount *)new FIX::UnderlyingDeliveryAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingDeliveryAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingDeliveryAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingDeliveryAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingDeliveryAmount.new", 
    "    UnderlyingDeliveryAmount.new()\n"
    "    UnderlyingDeliveryAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingDeliveryAmount(FIX::UnderlyingDeliveryAmount *arg1) {
    delete arg1;
}

swig_class SwigClassSideQty;

SWIGINTERN VALUE
_wrap_new_SideQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideQty";
  FIX::SideQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideQty *)new FIX::SideQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideQty";
  FIX::SideQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideQty *)new FIX::SideQty((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideQty.new", 
    "    SideQty.new()\n"
    "    SideQty.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideQty(FIX::SideQty *arg1) {
    delete arg1;
}

swig_class SwigClassCollAsgnTransType;

SWIGINTERN VALUE
_wrap_new_CollAsgnTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnTransType";
  FIX::CollAsgnTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAsgnTransType *)new FIX::CollAsgnTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAsgnTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAsgnTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAsgnTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAsgnTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnTransType";
  FIX::CollAsgnTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollAsgnTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollAsgnTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollAsgnTransType *)new FIX::CollAsgnTransType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAsgnTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAsgnTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAsgnTransType.new", 
    "    CollAsgnTransType.new()\n"
    "    CollAsgnTransType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnTransType(FIX::CollAsgnTransType *arg1) {
    delete arg1;
}

swig_class SwigClassThresholdAmount;

SWIGINTERN VALUE
_wrap_new_ThresholdAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ThresholdAmount";
  FIX::ThresholdAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ThresholdAmount *)new FIX::ThresholdAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ThresholdAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ThresholdAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ThresholdAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ThresholdAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ThresholdAmount";
  FIX::ThresholdAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::ThresholdAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::ThresholdAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::ThresholdAmount *)new FIX::ThresholdAmount((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ThresholdAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ThresholdAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ThresholdAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ThresholdAmount.new", 
    "    ThresholdAmount.new()\n"
    "    ThresholdAmount.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ThresholdAmount(FIX::ThresholdAmount *arg1) {
    delete arg1;
}

swig_class SwigClassDefBidSize;

SWIGINTERN VALUE
_wrap_new_DefBidSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DefBidSize";
  FIX::DefBidSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DefBidSize *)new FIX::DefBidSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DefBidSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DefBidSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DefBidSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DefBidSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefBidSize";
  FIX::DefBidSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DefBidSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DefBidSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DefBidSize *)new FIX::DefBidSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefBidSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DefBidSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefBidSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DefBidSize.new", 
    "    DefBidSize.new()\n"
    "    DefBidSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DefBidSize(FIX::DefBidSize *arg1) {
    delete arg1;
}

swig_class SwigClassLegStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_LegStateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegStateOrProvinceOfIssue";
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegStateOrProvinceOfIssue *)new FIX::LegStateOrProvinceOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegStateOrProvinceOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegStateOrProvinceOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegStateOrProvinceOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStateOrProvinceOfIssue";
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegStateOrProvinceOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegStateOrProvinceOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegStateOrProvinceOfIssue *)new FIX::LegStateOrProvinceOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegStateOrProvinceOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegStateOrProvinceOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStateOrProvinceOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegStateOrProvinceOfIssue.new", 
    "    LegStateOrProvinceOfIssue.new()\n"
    "    LegStateOrProvinceOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStateOrProvinceOfIssue(FIX::LegStateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassPaymentMethod;

SWIGINTERN VALUE
_wrap_new_PaymentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PaymentMethod";
  FIX::PaymentMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PaymentMethod *)new FIX::PaymentMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PaymentMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PaymentMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PaymentMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PaymentMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentMethod";
  FIX::PaymentMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PaymentMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PaymentMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PaymentMethod *)new FIX::PaymentMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PaymentMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PaymentMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PaymentMethod.new", 
    "    PaymentMethod.new()\n"
    "    PaymentMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentMethod(FIX::PaymentMethod *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegOptAttribute;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegOptAttribute";
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegOptAttribute *)new FIX::UnderlyingLegOptAttribute();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegOptAttribute_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegOptAttribute_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegOptAttribute);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegOptAttribute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegOptAttribute";
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::UnderlyingLegOptAttribute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::UnderlyingLegOptAttribute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::UnderlyingLegOptAttribute *)new FIX::UnderlyingLegOptAttribute((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegOptAttribute(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegOptAttribute__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegOptAttribute__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegOptAttribute.new", 
    "    UnderlyingLegOptAttribute.new()\n"
    "    UnderlyingLegOptAttribute.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegOptAttribute(FIX::UnderlyingLegOptAttribute *arg1) {
    delete arg1;
}

swig_class SwigClassLegVolatility;

SWIGINTERN VALUE
_wrap_new_LegVolatility__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegVolatility";
  FIX::LegVolatility *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegVolatility *)new FIX::LegVolatility();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegVolatility_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegVolatility_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegVolatility);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegVolatility__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegVolatility";
  FIX::LegVolatility *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::LegVolatility", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::LegVolatility", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::LegVolatility *)new FIX::LegVolatility((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegVolatility(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegVolatility__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegVolatility__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegVolatility.new", 
    "    LegVolatility.new()\n"
    "    LegVolatility.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegVolatility(FIX::LegVolatility *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrAttribType;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrAttribType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribType";
  FIX::DerivativeInstrAttribType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrAttribType *)new FIX::DerivativeInstrAttribType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrAttribType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrAttribType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrAttribType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrAttribType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribType";
  FIX::DerivativeInstrAttribType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeInstrAttribType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeInstrAttribType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeInstrAttribType *)new FIX::DerivativeInstrAttribType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrAttribType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrAttribType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrAttribType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrAttribType.new", 
    "    DerivativeInstrAttribType.new()\n"
    "    DerivativeInstrAttribType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrAttribType(FIX::DerivativeInstrAttribType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_DerivativeUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasureQty";
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeUnitOfMeasureQty *)new FIX::DerivativeUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasureQty";
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DerivativeUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DerivativeUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DerivativeUnitOfMeasureQty *)new FIX::DerivativeUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeUnitOfMeasureQty.new", 
    "    DerivativeUnitOfMeasureQty.new()\n"
    "    DerivativeUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeUnitOfMeasureQty(FIX::DerivativeUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassNoStatsIndicators;

SWIGINTERN VALUE
_wrap_new_NoStatsIndicators__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoStatsIndicators";
  FIX::NoStatsIndicators *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoStatsIndicators *)new FIX::NoStatsIndicators();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoStatsIndicators_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoStatsIndicators_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoStatsIndicators);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoStatsIndicators__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStatsIndicators";
  FIX::NoStatsIndicators *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoStatsIndicators", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoStatsIndicators", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoStatsIndicators *)new FIX::NoStatsIndicators((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoStatsIndicators(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoStatsIndicators__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStatsIndicators__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoStatsIndicators.new", 
    "    NoStatsIndicators.new()\n"
    "    NoStatsIndicators.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStatsIndicators(FIX::NoStatsIndicators *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerPriceTypeScope;

SWIGINTERN VALUE
_wrap_new_TriggerPriceTypeScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceTypeScope";
  FIX::TriggerPriceTypeScope *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerPriceTypeScope *)new FIX::TriggerPriceTypeScope();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerPriceTypeScope_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerPriceTypeScope_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerPriceTypeScope);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerPriceTypeScope__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceTypeScope";
  FIX::TriggerPriceTypeScope *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TriggerPriceTypeScope", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TriggerPriceTypeScope", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TriggerPriceTypeScope *)new FIX::TriggerPriceTypeScope((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerPriceTypeScope(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerPriceTypeScope__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPriceTypeScope__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerPriceTypeScope.new", 
    "    TriggerPriceTypeScope.new()\n"
    "    TriggerPriceTypeScope.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPriceTypeScope(FIX::TriggerPriceTypeScope *arg1) {
    delete arg1;
}

swig_class SwigClassLastNetworkResponseID;

SWIGINTERN VALUE
_wrap_new_LastNetworkResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastNetworkResponseID";
  FIX::LastNetworkResponseID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastNetworkResponseID *)new FIX::LastNetworkResponseID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastNetworkResponseID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastNetworkResponseID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastNetworkResponseID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastNetworkResponseID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastNetworkResponseID";
  FIX::LastNetworkResponseID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LastNetworkResponseID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LastNetworkResponseID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LastNetworkResponseID *)new FIX::LastNetworkResponseID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastNetworkResponseID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastNetworkResponseID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastNetworkResponseID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastNetworkResponseID.new", 
    "    LastNetworkResponseID.new()\n"
    "    LastNetworkResponseID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastNetworkResponseID(FIX::LastNetworkResponseID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSettlPriceType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPriceType";
  FIX::UnderlyingSettlPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSettlPriceType *)new FIX::UnderlyingSettlPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSettlPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSettlPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSettlPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPriceType";
  FIX::UnderlyingSettlPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingSettlPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingSettlPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingSettlPriceType *)new FIX::UnderlyingSettlPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSettlPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSettlPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSettlPriceType.new", 
    "    UnderlyingSettlPriceType.new()\n"
    "    UnderlyingSettlPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlPriceType(FIX::UnderlyingSettlPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassApplReportID;

SWIGINTERN VALUE
_wrap_new_ApplReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplReportID";
  FIX::ApplReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplReportID *)new FIX::ApplReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReportID";
  FIX::ApplReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ApplReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ApplReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ApplReportID *)new FIX::ApplReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplReportID.new", 
    "    ApplReportID.new()\n"
    "    ApplReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReportID(FIX::ApplReportID *arg1) {
    delete arg1;
}

swig_class SwigClassPegLimitType;

SWIGINTERN VALUE
_wrap_new_PegLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegLimitType";
  FIX::PegLimitType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegLimitType *)new FIX::PegLimitType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegLimitType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegLimitType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegLimitType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegLimitType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegLimitType";
  FIX::PegLimitType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PegLimitType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PegLimitType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PegLimitType *)new FIX::PegLimitType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegLimitType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegLimitType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegLimitType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegLimitType.new", 
    "    PegLimitType.new()\n"
    "    PegLimitType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegLimitType(FIX::PegLimitType *arg1) {
    delete arg1;
}

swig_class SwigClassExecID;

SWIGINTERN VALUE
_wrap_new_ExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecID";
  FIX::ExecID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecID *)new FIX::ExecID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecID";
  FIX::ExecID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ExecID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ExecID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ExecID *)new FIX::ExecID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecID.new", 
    "    ExecID.new()\n"
    "    ExecID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecID(FIX::ExecID *arg1) {
    delete arg1;
}

swig_class SwigClassSide;

SWIGINTERN VALUE
_wrap_new_Side__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Side";
  FIX::Side *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Side *)new FIX::Side();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Side_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Side_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Side);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Side__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Side";
  FIX::Side *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Side", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Side", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Side *)new FIX::Side((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Side(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Side__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Side__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Side.new", 
    "    Side.new()\n"
    "    Side.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Side(FIX::Side *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLastPx;

SWIGINTERN VALUE
_wrap_new_UnderlyingLastPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastPx";
  FIX::UnderlyingLastPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLastPx *)new FIX::UnderlyingLastPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLastPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLastPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLastPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLastPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastPx";
  FIX::UnderlyingLastPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingLastPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingLastPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingLastPx *)new FIX::UnderlyingLastPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLastPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLastPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLastPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLastPx.new", 
    "    UnderlyingLastPx.new()\n"
    "    UnderlyingLastPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLastPx(FIX::UnderlyingLastPx *arg1) {
    delete arg1;
}

swig_class SwigClassMarketDepth;

SWIGINTERN VALUE
_wrap_new_MarketDepth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketDepth";
  FIX::MarketDepth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketDepth *)new FIX::MarketDepth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketDepth_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketDepth_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketDepth);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketDepth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketDepth";
  FIX::MarketDepth *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MarketDepth", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MarketDepth", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MarketDepth *)new FIX::MarketDepth((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketDepth(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketDepth__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketDepth__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketDepth.new", 
    "    MarketDepth.new()\n"
    "    MarketDepth.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketDepth(FIX::MarketDepth *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionOffset;

SWIGINTERN VALUE
_wrap_new_DiscretionOffset__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffset";
  FIX::DiscretionOffset *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionOffset *)new FIX::DiscretionOffset();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionOffset_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionOffset_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionOffset);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionOffset__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffset";
  FIX::DiscretionOffset *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::DiscretionOffset", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::DiscretionOffset", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::DiscretionOffset *)new FIX::DiscretionOffset((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionOffset(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionOffset__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionOffset__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionOffset.new", 
    "    DiscretionOffset.new()\n"
    "    DiscretionOffset.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionOffset(FIX::DiscretionOffset *arg1) {
    delete arg1;
}

swig_class SwigClassContAmtType;

SWIGINTERN VALUE
_wrap_new_ContAmtType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContAmtType";
  FIX::ContAmtType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContAmtType *)new FIX::ContAmtType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContAmtType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContAmtType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContAmtType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContAmtType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtType";
  FIX::ContAmtType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ContAmtType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ContAmtType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ContAmtType *)new FIX::ContAmtType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContAmtType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContAmtType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContAmtType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContAmtType.new", 
    "    ContAmtType.new()\n"
    "    ContAmtType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContAmtType(FIX::ContAmtType *arg1) {
    delete arg1;
}

swig_class SwigClassMiscFeeCurr;

SWIGINTERN VALUE
_wrap_new_MiscFeeCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeCurr";
  FIX::MiscFeeCurr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MiscFeeCurr *)new FIX::MiscFeeCurr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MiscFeeCurr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MiscFeeCurr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MiscFeeCurr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MiscFeeCurr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeCurr";
  FIX::MiscFeeCurr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::MiscFeeCurr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::MiscFeeCurr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::MiscFeeCurr *)new FIX::MiscFeeCurr((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MiscFeeCurr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MiscFeeCurr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeCurr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MiscFeeCurr.new", 
    "    MiscFeeCurr.new()\n"
    "    MiscFeeCurr.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeCurr(FIX::MiscFeeCurr *arg1) {
    delete arg1;
}

swig_class SwigClassAttachmentPoint;

SWIGINTERN VALUE
_wrap_new_AttachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AttachmentPoint";
  FIX::AttachmentPoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AttachmentPoint *)new FIX::AttachmentPoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AttachmentPoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AttachmentPoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AttachmentPoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AttachmentPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AttachmentPoint";
  FIX::AttachmentPoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::AttachmentPoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::AttachmentPoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::AttachmentPoint *)new FIX::AttachmentPoint((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AttachmentPoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AttachmentPoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttachmentPoint__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AttachmentPoint.new", 
    "    AttachmentPoint.new()\n"
    "    AttachmentPoint.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AttachmentPoint(FIX::AttachmentPoint *arg1) {
    delete arg1;
}

swig_class SwigClassOrderCategory;

SWIGINTERN VALUE
_wrap_new_OrderCategory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderCategory";
  FIX::OrderCategory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderCategory *)new FIX::OrderCategory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderCategory_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderCategory_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderCategory);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderCategory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCategory";
  FIX::OrderCategory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OrderCategory", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OrderCategory", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OrderCategory *)new FIX::OrderCategory((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderCategory(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderCategory__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderCategory__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderCategory.new", 
    "    OrderCategory.new()\n"
    "    OrderCategory.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderCategory(FIX::OrderCategory *arg1) {
    delete arg1;
}

swig_class SwigClassAdvTransType;

SWIGINTERN VALUE
_wrap_new_AdvTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AdvTransType";
  FIX::AdvTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AdvTransType *)new FIX::AdvTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AdvTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AdvTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AdvTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AdvTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvTransType";
  FIX::AdvTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AdvTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AdvTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AdvTransType *)new FIX::AdvTransType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AdvTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AdvTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AdvTransType.new", 
    "    AdvTransType.new()\n"
    "    AdvTransType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvTransType(FIX::AdvTransType *arg1) {
    delete arg1;
}

swig_class SwigClassWtAverageLiquidity;

SWIGINTERN VALUE
_wrap_new_WtAverageLiquidity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::WtAverageLiquidity";
  FIX::WtAverageLiquidity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::WtAverageLiquidity *)new FIX::WtAverageLiquidity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_WtAverageLiquidity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_WtAverageLiquidity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__WtAverageLiquidity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_WtAverageLiquidity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WtAverageLiquidity";
  FIX::WtAverageLiquidity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::WtAverageLiquidity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::WtAverageLiquidity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::WtAverageLiquidity *)new FIX::WtAverageLiquidity((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_WtAverageLiquidity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_WtAverageLiquidity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WtAverageLiquidity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "WtAverageLiquidity.new", 
    "    WtAverageLiquidity.new()\n"
    "    WtAverageLiquidity.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_WtAverageLiquidity(FIX::WtAverageLiquidity *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteSetValidUntilTime;

SWIGINTERN VALUE
_wrap_new_QuoteSetValidUntilTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_QuoteSetValidUntilTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::QuoteSetValidUntilTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_QuoteSetValidUntilTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::QuoteSetValidUntilTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::QuoteSetValidUntilTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteSetValidUntilTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteSetValidUntilTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteSetValidUntilTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteSetValidUntilTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::QuoteSetValidUntilTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::QuoteSetValidUntilTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::QuoteSetValidUntilTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteSetValidUntilTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteSetValidUntilTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteSetValidUntilTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_QuoteSetValidUntilTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_QuoteSetValidUntilTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "QuoteSetValidUntilTime.new", 
    "    QuoteSetValidUntilTime.new()\n"
    "    QuoteSetValidUntilTime.new(bool showMilliseconds)\n"
    "    QuoteSetValidUntilTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    QuoteSetValidUntilTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteSetValidUntilTime(FIX::QuoteSetValidUntilTime *arg1) {
    delete arg1;
}

swig_class SwigClassNoNested4PartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNested4PartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartyIDs";
  FIX::NoNested4PartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNested4PartyIDs *)new FIX::NoNested4PartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNested4PartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNested4PartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNested4PartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNested4PartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartyIDs";
  FIX::NoNested4PartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNested4PartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNested4PartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNested4PartyIDs *)new FIX::NoNested4PartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNested4PartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNested4PartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested4PartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNested4PartyIDs.new", 
    "    NoNested4PartyIDs.new()\n"
    "    NoNested4PartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested4PartyIDs(FIX::NoNested4PartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassLegPutOrCall;

SWIGINTERN VALUE
_wrap_new_LegPutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPutOrCall";
  FIX::LegPutOrCall *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPutOrCall *)new FIX::LegPutOrCall();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPutOrCall_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPutOrCall_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPutOrCall);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPutOrCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPutOrCall";
  FIX::LegPutOrCall *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegPutOrCall", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegPutOrCall", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegPutOrCall *)new FIX::LegPutOrCall((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPutOrCall.new", 
    "    LegPutOrCall.new()\n"
    "    LegPutOrCall.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPutOrCall(FIX::LegPutOrCall *arg1) {
    delete arg1;
}

swig_class SwigClassUserStatusText;

SWIGINTERN VALUE
_wrap_new_UserStatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UserStatusText";
  FIX::UserStatusText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UserStatusText *)new FIX::UserStatusText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UserStatusText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UserStatusText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UserStatusText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UserStatusText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserStatusText";
  FIX::UserStatusText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UserStatusText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UserStatusText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UserStatusText *)new FIX::UserStatusText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UserStatusText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UserStatusText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserStatusText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UserStatusText.new", 
    "    UserStatusText.new()\n"
    "    UserStatusText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UserStatusText(FIX::UserStatusText *arg1) {
    delete arg1;
}

swig_class SwigClassNested2PartySubID;

SWIGINTERN VALUE
_wrap_new_Nested2PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubID";
  FIX::Nested2PartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested2PartySubID *)new FIX::Nested2PartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested2PartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested2PartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested2PartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested2PartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubID";
  FIX::Nested2PartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Nested2PartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Nested2PartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Nested2PartySubID *)new FIX::Nested2PartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested2PartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested2PartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested2PartySubID.new", 
    "    Nested2PartySubID.new()\n"
    "    Nested2PartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartySubID(FIX::Nested2PartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassEFPTrackingError;

SWIGINTERN VALUE
_wrap_new_EFPTrackingError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EFPTrackingError";
  FIX::EFPTrackingError *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EFPTrackingError *)new FIX::EFPTrackingError();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EFPTrackingError_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EFPTrackingError_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EFPTrackingError);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EFPTrackingError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EFPTrackingError";
  FIX::EFPTrackingError *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::EFPTrackingError", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::EFPTrackingError", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::EFPTrackingError *)new FIX::EFPTrackingError((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EFPTrackingError(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EFPTrackingError__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EFPTrackingError__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EFPTrackingError.new", 
    "    EFPTrackingError.new()\n"
    "    EFPTrackingError.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EFPTrackingError(FIX::EFPTrackingError *arg1) {
    delete arg1;
}

swig_class SwigClassSideLiquidityInd;

SWIGINTERN VALUE
_wrap_new_SideLiquidityInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideLiquidityInd";
  FIX::SideLiquidityInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideLiquidityInd *)new FIX::SideLiquidityInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideLiquidityInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideLiquidityInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideLiquidityInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideLiquidityInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideLiquidityInd";
  FIX::SideLiquidityInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideLiquidityInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideLiquidityInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideLiquidityInd *)new FIX::SideLiquidityInd((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideLiquidityInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideLiquidityInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideLiquidityInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideLiquidityInd.new", 
    "    SideLiquidityInd.new()\n"
    "    SideLiquidityInd.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideLiquidityInd(FIX::SideLiquidityInd *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeMinPriceIncrement;

SWIGINTERN VALUE
_wrap_new_DerivativeMinPriceIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrement";
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeMinPriceIncrement *)new FIX::DerivativeMinPriceIncrement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeMinPriceIncrement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeMinPriceIncrement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeMinPriceIncrement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeMinPriceIncrement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrement";
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::DerivativeMinPriceIncrement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::DerivativeMinPriceIncrement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::DerivativeMinPriceIncrement *)new FIX::DerivativeMinPriceIncrement((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeMinPriceIncrement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeMinPriceIncrement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMinPriceIncrement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeMinPriceIncrement.new", 
    "    DerivativeMinPriceIncrement.new()\n"
    "    DerivativeMinPriceIncrement.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMinPriceIncrement(FIX::DerivativeMinPriceIncrement *arg1) {
    delete arg1;
}

swig_class SwigClassPublishTrdIndicator;

SWIGINTERN VALUE
_wrap_new_PublishTrdIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PublishTrdIndicator";
  FIX::PublishTrdIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PublishTrdIndicator *)new FIX::PublishTrdIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PublishTrdIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PublishTrdIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PublishTrdIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PublishTrdIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PublishTrdIndicator";
  FIX::PublishTrdIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PublishTrdIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PublishTrdIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PublishTrdIndicator *)new FIX::PublishTrdIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PublishTrdIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PublishTrdIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PublishTrdIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PublishTrdIndicator.new", 
    "    PublishTrdIndicator.new()\n"
    "    PublishTrdIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PublishTrdIndicator(FIX::PublishTrdIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassInvestorCountryOfResidence;

SWIGINTERN VALUE
_wrap_new_InvestorCountryOfResidence__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InvestorCountryOfResidence";
  FIX::InvestorCountryOfResidence *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InvestorCountryOfResidence *)new FIX::InvestorCountryOfResidence();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InvestorCountryOfResidence_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InvestorCountryOfResidence_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InvestorCountryOfResidence);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InvestorCountryOfResidence__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvestorCountryOfResidence";
  FIX::InvestorCountryOfResidence *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__COUNTRY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::COUNTRY const &","FIX::InvestorCountryOfResidence", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::COUNTRY const &","FIX::InvestorCountryOfResidence", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  result = (FIX::InvestorCountryOfResidence *)new FIX::InvestorCountryOfResidence((FIX::COUNTRY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InvestorCountryOfResidence(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InvestorCountryOfResidence__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvestorCountryOfResidence__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InvestorCountryOfResidence.new", 
    "    InvestorCountryOfResidence.new()\n"
    "    InvestorCountryOfResidence.new(FIX::COUNTRY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InvestorCountryOfResidence(FIX::InvestorCountryOfResidence *arg1) {
    delete arg1;
}

swig_class SwigClassSideReasonCd;

SWIGINTERN VALUE
_wrap_new_SideReasonCd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideReasonCd";
  FIX::SideReasonCd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideReasonCd *)new FIX::SideReasonCd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideReasonCd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideReasonCd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideReasonCd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideReasonCd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideReasonCd";
  FIX::SideReasonCd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SideReasonCd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SideReasonCd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SideReasonCd *)new FIX::SideReasonCd((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideReasonCd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideReasonCd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideReasonCd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideReasonCd.new", 
    "    SideReasonCd.new()\n"
    "    SideReasonCd.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideReasonCd(FIX::SideReasonCd *arg1) {
    delete arg1;
}

swig_class SwigClassMinPriceIncrement;

SWIGINTERN VALUE
_wrap_new_MinPriceIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrement";
  FIX::MinPriceIncrement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinPriceIncrement *)new FIX::MinPriceIncrement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinPriceIncrement_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinPriceIncrement_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinPriceIncrement);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinPriceIncrement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrement";
  FIX::MinPriceIncrement *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::MinPriceIncrement", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::MinPriceIncrement", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::MinPriceIncrement *)new FIX::MinPriceIncrement((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinPriceIncrement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinPriceIncrement__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinPriceIncrement__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinPriceIncrement.new", 
    "    MinPriceIncrement.new()\n"
    "    MinPriceIncrement.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinPriceIncrement(FIX::MinPriceIncrement *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySettlAgentContactName;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentContactName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactName";
  FIX::SecuritySettlAgentContactName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySettlAgentContactName *)new FIX::SecuritySettlAgentContactName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySettlAgentContactName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySettlAgentContactName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySettlAgentContactName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentContactName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactName";
  FIX::SecuritySettlAgentContactName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySettlAgentContactName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySettlAgentContactName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySettlAgentContactName *)new FIX::SecuritySettlAgentContactName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySettlAgentContactName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySettlAgentContactName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentContactName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySettlAgentContactName.new", 
    "    SecuritySettlAgentContactName.new()\n"
    "    SecuritySettlAgentContactName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentContactName(FIX::SecuritySettlAgentContactName *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityResponseType;

SWIGINTERN VALUE
_wrap_new_SecurityResponseType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseType";
  FIX::SecurityResponseType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityResponseType *)new FIX::SecurityResponseType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityResponseType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityResponseType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityResponseType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityResponseType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseType";
  FIX::SecurityResponseType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityResponseType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityResponseType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityResponseType *)new FIX::SecurityResponseType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityResponseType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityResponseType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityResponseType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityResponseType.new", 
    "    SecurityResponseType.new()\n"
    "    SecurityResponseType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityResponseType(FIX::SecurityResponseType *arg1) {
    delete arg1;
}

swig_class SwigClassLegBenchmarkCurvePoint;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurvePoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurvePoint";
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBenchmarkCurvePoint *)new FIX::LegBenchmarkCurvePoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBenchmarkCurvePoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBenchmarkCurvePoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBenchmarkCurvePoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurvePoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurvePoint";
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegBenchmarkCurvePoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegBenchmarkCurvePoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegBenchmarkCurvePoint *)new FIX::LegBenchmarkCurvePoint((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBenchmarkCurvePoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBenchmarkCurvePoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkCurvePoint__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBenchmarkCurvePoint.new", 
    "    LegBenchmarkCurvePoint.new()\n"
    "    LegBenchmarkCurvePoint.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkCurvePoint(FIX::LegBenchmarkCurvePoint *arg1) {
    delete arg1;
}

swig_class SwigClassClearingFirm;

SWIGINTERN VALUE
_wrap_new_ClearingFirm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClearingFirm";
  FIX::ClearingFirm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClearingFirm *)new FIX::ClearingFirm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClearingFirm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClearingFirm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClearingFirm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClearingFirm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingFirm";
  FIX::ClearingFirm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClearingFirm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClearingFirm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClearingFirm *)new FIX::ClearingFirm((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClearingFirm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClearingFirm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingFirm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClearingFirm.new", 
    "    ClearingFirm.new()\n"
    "    ClearingFirm.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingFirm(FIX::ClearingFirm *arg1) {
    delete arg1;
}

swig_class SwigClassSessionStatus;

SWIGINTERN VALUE
_wrap_new_SessionStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SessionStatus";
  FIX::SessionStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SessionStatus *)new FIX::SessionStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SessionStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SessionStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SessionStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SessionStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionStatus";
  FIX::SessionStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SessionStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SessionStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SessionStatus *)new FIX::SessionStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SessionStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SessionStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SessionStatus.new", 
    "    SessionStatus.new()\n"
    "    SessionStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionStatus(FIX::SessionStatus *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerSecurityID;

SWIGINTERN VALUE
_wrap_new_TriggerSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityID";
  FIX::TriggerSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerSecurityID *)new FIX::TriggerSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityID";
  FIX::TriggerSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TriggerSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TriggerSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TriggerSecurityID *)new FIX::TriggerSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerSecurityID.new", 
    "    TriggerSecurityID.new()\n"
    "    TriggerSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSecurityID(FIX::TriggerSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoAllocs;

SWIGINTERN VALUE
_wrap_new_TotNoAllocs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoAllocs";
  FIX::TotNoAllocs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoAllocs *)new FIX::TotNoAllocs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoAllocs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoAllocs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoAllocs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoAllocs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoAllocs";
  FIX::TotNoAllocs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoAllocs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoAllocs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoAllocs *)new FIX::TotNoAllocs((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoAllocs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoAllocs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoAllocs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoAllocs.new", 
    "    TotNoAllocs.new()\n"
    "    TotNoAllocs.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoAllocs(FIX::TotNoAllocs *arg1) {
    delete arg1;
}

swig_class SwigClassNoAltMDSource;

SWIGINTERN VALUE
_wrap_new_NoAltMDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoAltMDSource";
  FIX::NoAltMDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoAltMDSource *)new FIX::NoAltMDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoAltMDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoAltMDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoAltMDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoAltMDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAltMDSource";
  FIX::NoAltMDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoAltMDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoAltMDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoAltMDSource *)new FIX::NoAltMDSource((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoAltMDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoAltMDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAltMDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoAltMDSource.new", 
    "    NoAltMDSource.new()\n"
    "    NoAltMDSource.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAltMDSource(FIX::NoAltMDSource *arg1) {
    delete arg1;
}

swig_class SwigClassAllocAccountType;

SWIGINTERN VALUE
_wrap_new_AllocAccountType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocAccountType";
  FIX::AllocAccountType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocAccountType *)new FIX::AllocAccountType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocAccountType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocAccountType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocAccountType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocAccountType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccountType";
  FIX::AllocAccountType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocAccountType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocAccountType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocAccountType *)new FIX::AllocAccountType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocAccountType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocAccountType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAccountType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocAccountType.new", 
    "    AllocAccountType.new()\n"
    "    AllocAccountType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAccountType(FIX::AllocAccountType *arg1) {
    delete arg1;
}

swig_class SwigClassLastPx;

SWIGINTERN VALUE
_wrap_new_LastPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastPx";
  FIX::LastPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastPx *)new FIX::LastPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastPx";
  FIX::LastPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LastPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LastPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LastPx *)new FIX::LastPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastPx.new", 
    "    LastPx.new()\n"
    "    LastPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastPx(FIX::LastPx *arg1) {
    delete arg1;
}

swig_class SwigClassAllocTransType;

SWIGINTERN VALUE
_wrap_new_AllocTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocTransType";
  FIX::AllocTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocTransType *)new FIX::AllocTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocTransType";
  FIX::AllocTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::AllocTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::AllocTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::AllocTransType *)new FIX::AllocTransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocTransType.new", 
    "    AllocTransType.new()\n"
    "    AllocTransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocTransType(FIX::AllocTransType *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoQuoteEntries;

SWIGINTERN VALUE
_wrap_new_TotNoQuoteEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoQuoteEntries";
  FIX::TotNoQuoteEntries *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoQuoteEntries *)new FIX::TotNoQuoteEntries();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoQuoteEntries_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoQuoteEntries_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoQuoteEntries);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoQuoteEntries__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoQuoteEntries";
  FIX::TotNoQuoteEntries *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoQuoteEntries", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoQuoteEntries", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoQuoteEntries *)new FIX::TotNoQuoteEntries((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoQuoteEntries(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoQuoteEntries__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoQuoteEntries__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoQuoteEntries.new", 
    "    TotNoQuoteEntries.new()\n"
    "    TotNoQuoteEntries.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoQuoteEntries(FIX::TotNoQuoteEntries *arg1) {
    delete arg1;
}

swig_class SwigClassMinBidSize;

SWIGINTERN VALUE
_wrap_new_MinBidSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinBidSize";
  FIX::MinBidSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinBidSize *)new FIX::MinBidSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinBidSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinBidSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinBidSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinBidSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinBidSize";
  FIX::MinBidSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MinBidSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MinBidSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MinBidSize *)new FIX::MinBidSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinBidSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinBidSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinBidSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinBidSize.new", 
    "    MinBidSize.new()\n"
    "    MinBidSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinBidSize(FIX::MinBidSize *arg1) {
    delete arg1;
}

swig_class SwigClassSettlBrkrCode;

SWIGINTERN VALUE
_wrap_new_SettlBrkrCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlBrkrCode";
  FIX::SettlBrkrCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlBrkrCode *)new FIX::SettlBrkrCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlBrkrCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlBrkrCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlBrkrCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlBrkrCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlBrkrCode";
  FIX::SettlBrkrCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlBrkrCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlBrkrCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlBrkrCode *)new FIX::SettlBrkrCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlBrkrCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlBrkrCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlBrkrCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlBrkrCode.new", 
    "    SettlBrkrCode.new()\n"
    "    SettlBrkrCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlBrkrCode(FIX::SettlBrkrCode *arg1) {
    delete arg1;
}

swig_class SwigClassCardHolderName;

SWIGINTERN VALUE
_wrap_new_CardHolderName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CardHolderName";
  FIX::CardHolderName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CardHolderName *)new FIX::CardHolderName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CardHolderName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CardHolderName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CardHolderName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CardHolderName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardHolderName";
  FIX::CardHolderName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CardHolderName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CardHolderName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CardHolderName *)new FIX::CardHolderName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CardHolderName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CardHolderName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardHolderName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CardHolderName.new", 
    "    CardHolderName.new()\n"
    "    CardHolderName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CardHolderName(FIX::CardHolderName *arg1) {
    delete arg1;
}

swig_class SwigClassExpirationQtyType;

SWIGINTERN VALUE
_wrap_new_ExpirationQtyType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExpirationQtyType";
  FIX::ExpirationQtyType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExpirationQtyType *)new FIX::ExpirationQtyType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExpirationQtyType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExpirationQtyType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExpirationQtyType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExpirationQtyType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpirationQtyType";
  FIX::ExpirationQtyType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ExpirationQtyType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ExpirationQtyType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ExpirationQtyType *)new FIX::ExpirationQtyType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExpirationQtyType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExpirationQtyType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpirationQtyType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExpirationQtyType.new", 
    "    ExpirationQtyType.new()\n"
    "    ExpirationQtyType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpirationQtyType(FIX::ExpirationQtyType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedUnderlyingSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDescLen";
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedUnderlyingSecurityDescLen *)new FIX::EncodedUnderlyingSecurityDescLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedUnderlyingSecurityDescLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedUnderlyingSecurityDescLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDescLen";
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedUnderlyingSecurityDescLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedUnderlyingSecurityDescLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedUnderlyingSecurityDescLen *)new FIX::EncodedUnderlyingSecurityDescLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedUnderlyingSecurityDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedUnderlyingSecurityDescLen.new", 
    "    EncodedUnderlyingSecurityDescLen.new()\n"
    "    EncodedUnderlyingSecurityDescLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingSecurityDescLen(FIX::EncodedUnderlyingSecurityDescLen *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteReqID;

SWIGINTERN VALUE
_wrap_new_QuoteReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteReqID";
  FIX::QuoteReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteReqID *)new FIX::QuoteReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteReqID";
  FIX::QuoteReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteReqID *)new FIX::QuoteReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteReqID.new", 
    "    QuoteReqID.new()\n"
    "    QuoteReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteReqID(FIX::QuoteReqID *arg1) {
    delete arg1;
}

swig_class SwigClassPriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_PriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasure";
  FIX::PriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceUnitOfMeasure *)new FIX::PriceUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasure";
  FIX::PriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PriceUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PriceUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PriceUnitOfMeasure *)new FIX::PriceUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceUnitOfMeasure.new", 
    "    PriceUnitOfMeasure.new()\n"
    "    PriceUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceUnitOfMeasure(FIX::PriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassTZTransactTime;

SWIGINTERN VALUE
_wrap_new_TZTransactTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TZTransactTime";
  FIX::TZTransactTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TZTransactTime *)new FIX::TZTransactTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TZTransactTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TZTransactTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TZTransactTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TZTransactTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TZTransactTime";
  FIX::TZTransactTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__TZTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TZTIMESTAMP const &","FIX::TZTransactTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TZTIMESTAMP const &","FIX::TZTransactTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMESTAMP * >(argp1);
  result = (FIX::TZTransactTime *)new FIX::TZTransactTime((FIX::TZTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TZTransactTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TZTransactTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__TZTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TZTransactTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TZTransactTime.new", 
    "    TZTransactTime.new()\n"
    "    TZTransactTime.new(FIX::TZTIMESTAMP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TZTransactTime(FIX::TZTransactTime *arg1) {
    delete arg1;
}

swig_class SwigClassAllocHandlInst;

SWIGINTERN VALUE
_wrap_new_AllocHandlInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocHandlInst";
  FIX::AllocHandlInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocHandlInst *)new FIX::AllocHandlInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocHandlInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocHandlInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocHandlInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocHandlInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocHandlInst";
  FIX::AllocHandlInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocHandlInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocHandlInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocHandlInst *)new FIX::AllocHandlInst((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocHandlInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocHandlInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocHandlInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocHandlInst.new", 
    "    AllocHandlInst.new()\n"
    "    AllocHandlInst.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocHandlInst(FIX::AllocHandlInst *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyIDSource";
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingInstrumentPartyIDSource *)new FIX::UnderlyingInstrumentPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingInstrumentPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingInstrumentPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyIDSource";
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::UnderlyingInstrumentPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::UnderlyingInstrumentPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::UnderlyingInstrumentPartyIDSource *)new FIX::UnderlyingInstrumentPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingInstrumentPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingInstrumentPartyIDSource.new", 
    "    UnderlyingInstrumentPartyIDSource.new()\n"
    "    UnderlyingInstrumentPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartyIDSource(FIX::UnderlyingInstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassCurrencyRatio;

SWIGINTERN VALUE
_wrap_new_CurrencyRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CurrencyRatio";
  FIX::CurrencyRatio *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CurrencyRatio *)new FIX::CurrencyRatio();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CurrencyRatio_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CurrencyRatio_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CurrencyRatio);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CurrencyRatio__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CurrencyRatio";
  FIX::CurrencyRatio *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::CurrencyRatio", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::CurrencyRatio", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::CurrencyRatio *)new FIX::CurrencyRatio((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CurrencyRatio(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CurrencyRatio__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CurrencyRatio__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CurrencyRatio.new", 
    "    CurrencyRatio.new()\n"
    "    CurrencyRatio.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CurrencyRatio(FIX::CurrencyRatio *arg1) {
    delete arg1;
}

swig_class SwigClassRefreshQty;

SWIGINTERN VALUE
_wrap_new_RefreshQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefreshQty";
  FIX::RefreshQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefreshQty *)new FIX::RefreshQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefreshQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefreshQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefreshQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefreshQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefreshQty";
  FIX::RefreshQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::RefreshQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::RefreshQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::RefreshQty *)new FIX::RefreshQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefreshQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefreshQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefreshQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefreshQty.new", 
    "    RefreshQty.new()\n"
    "    RefreshQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefreshQty(FIX::RefreshQty *arg1) {
    delete arg1;
}

swig_class SwigClassTradeRequestStatus;

SWIGINTERN VALUE
_wrap_new_TradeRequestStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestStatus";
  FIX::TradeRequestStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeRequestStatus *)new FIX::TradeRequestStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeRequestStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeRequestStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeRequestStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeRequestStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestStatus";
  FIX::TradeRequestStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeRequestStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeRequestStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeRequestStatus *)new FIX::TradeRequestStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeRequestStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeRequestStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeRequestStatus.new", 
    "    TradeRequestStatus.new()\n"
    "    TradeRequestStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestStatus(FIX::TradeRequestStatus *arg1) {
    delete arg1;
}

swig_class SwigClassTrdRepIndicator;

SWIGINTERN VALUE
_wrap_new_TrdRepIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdRepIndicator";
  FIX::TrdRepIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdRepIndicator *)new FIX::TrdRepIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdRepIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdRepIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdRepIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdRepIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRepIndicator";
  FIX::TrdRepIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::TrdRepIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::TrdRepIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::TrdRepIndicator *)new FIX::TrdRepIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdRepIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdRepIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRepIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdRepIndicator.new", 
    "    TrdRepIndicator.new()\n"
    "    TrdRepIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRepIndicator(FIX::TrdRepIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassMiscFeeAmt;

SWIGINTERN VALUE
_wrap_new_MiscFeeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeAmt";
  FIX::MiscFeeAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MiscFeeAmt *)new FIX::MiscFeeAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MiscFeeAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MiscFeeAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MiscFeeAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MiscFeeAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeAmt";
  FIX::MiscFeeAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::MiscFeeAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::MiscFeeAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::MiscFeeAmt *)new FIX::MiscFeeAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MiscFeeAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MiscFeeAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MiscFeeAmt.new", 
    "    MiscFeeAmt.new()\n"
    "    MiscFeeAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeAmt(FIX::MiscFeeAmt *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesOpenTime;

SWIGINTERN VALUE
_wrap_new_TradSesOpenTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  FIX::TradSesOpenTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesOpenTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  FIX::TradSesOpenTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TradSesOpenTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesOpenTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  FIX::TradSesOpenTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesOpenTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesOpenTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesOpenTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesOpenTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesOpenTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesOpenTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  FIX::TradSesOpenTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesOpenTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesOpenTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TradSesOpenTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesOpenTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesOpenTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesOpenTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TradSesOpenTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesOpenTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TradSesOpenTime.new", 
    "    TradSesOpenTime.new()\n"
    "    TradSesOpenTime.new(bool showMilliseconds)\n"
    "    TradSesOpenTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TradSesOpenTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesOpenTime(FIX::TradSesOpenTime *arg1) {
    delete arg1;
}

swig_class SwigClassPreallocMethod;

SWIGINTERN VALUE
_wrap_new_PreallocMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PreallocMethod";
  FIX::PreallocMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PreallocMethod *)new FIX::PreallocMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PreallocMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PreallocMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PreallocMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PreallocMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreallocMethod";
  FIX::PreallocMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::PreallocMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::PreallocMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::PreallocMethod *)new FIX::PreallocMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PreallocMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PreallocMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PreallocMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PreallocMethod.new", 
    "    PreallocMethod.new()\n"
    "    PreallocMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PreallocMethod(FIX::PreallocMethod *arg1) {
    delete arg1;
}

swig_class SwigClassTaxAdvantageType;

SWIGINTERN VALUE
_wrap_new_TaxAdvantageType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TaxAdvantageType";
  FIX::TaxAdvantageType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TaxAdvantageType *)new FIX::TaxAdvantageType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TaxAdvantageType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TaxAdvantageType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TaxAdvantageType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TaxAdvantageType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TaxAdvantageType";
  FIX::TaxAdvantageType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TaxAdvantageType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TaxAdvantageType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TaxAdvantageType *)new FIX::TaxAdvantageType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TaxAdvantageType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TaxAdvantageType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TaxAdvantageType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TaxAdvantageType.new", 
    "    TaxAdvantageType.new()\n"
    "    TaxAdvantageType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TaxAdvantageType(FIX::TaxAdvantageType *arg1) {
    delete arg1;
}

swig_class SwigClassMessageEncoding;

SWIGINTERN VALUE
_wrap_new_MessageEncoding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MessageEncoding";
  FIX::MessageEncoding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MessageEncoding *)new FIX::MessageEncoding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MessageEncoding_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MessageEncoding_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MessageEncoding);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MessageEncoding__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageEncoding";
  FIX::MessageEncoding *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MessageEncoding", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MessageEncoding", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MessageEncoding *)new FIX::MessageEncoding((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MessageEncoding(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MessageEncoding__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MessageEncoding__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MessageEncoding.new", 
    "    MessageEncoding.new()\n"
    "    MessageEncoding.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageEncoding(FIX::MessageEncoding *arg1) {
    delete arg1;
}

swig_class SwigClassNoPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoPartySubIDs";
  FIX::NoPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoPartySubIDs *)new FIX::NoPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartySubIDs";
  FIX::NoPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartySubIDs *)new FIX::NoPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoPartySubIDs.new", 
    "    NoPartySubIDs.new()\n"
    "    NoPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartySubIDs(FIX::NoPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstReqID;

SWIGINTERN VALUE
_wrap_new_SettlInstReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqID";
  FIX::SettlInstReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstReqID *)new FIX::SettlInstReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqID";
  FIX::SettlInstReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlInstReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlInstReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlInstReqID *)new FIX::SettlInstReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstReqID.new", 
    "    SettlInstReqID.new()\n"
    "    SettlInstReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstReqID(FIX::SettlInstReqID *arg1) {
    delete arg1;
}

swig_class SwigClassLegRepoCollateralSecurityType;

SWIGINTERN VALUE
_wrap_new_LegRepoCollateralSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegRepoCollateralSecurityType";
  FIX::LegRepoCollateralSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegRepoCollateralSecurityType *)new FIX::LegRepoCollateralSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegRepoCollateralSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegRepoCollateralSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegRepoCollateralSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegRepoCollateralSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepoCollateralSecurityType";
  FIX::LegRepoCollateralSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegRepoCollateralSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegRepoCollateralSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegRepoCollateralSecurityType *)new FIX::LegRepoCollateralSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegRepoCollateralSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegRepoCollateralSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepoCollateralSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegRepoCollateralSecurityType.new", 
    "    LegRepoCollateralSecurityType.new()\n"
    "    LegRepoCollateralSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRepoCollateralSecurityType(FIX::LegRepoCollateralSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassAffectedSecondaryOrderID;

SWIGINTERN VALUE
_wrap_new_AffectedSecondaryOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AffectedSecondaryOrderID";
  FIX::AffectedSecondaryOrderID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AffectedSecondaryOrderID *)new FIX::AffectedSecondaryOrderID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AffectedSecondaryOrderID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AffectedSecondaryOrderID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AffectedSecondaryOrderID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AffectedSecondaryOrderID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffectedSecondaryOrderID";
  FIX::AffectedSecondaryOrderID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AffectedSecondaryOrderID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AffectedSecondaryOrderID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AffectedSecondaryOrderID *)new FIX::AffectedSecondaryOrderID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AffectedSecondaryOrderID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AffectedSecondaryOrderID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AffectedSecondaryOrderID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AffectedSecondaryOrderID.new", 
    "    AffectedSecondaryOrderID.new()\n"
    "    AffectedSecondaryOrderID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AffectedSecondaryOrderID(FIX::AffectedSecondaryOrderID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeMaturityTime;

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityTime";
  FIX::DerivativeMaturityTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeMaturityTime *)new FIX::DerivativeMaturityTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeMaturityTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeMaturityTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeMaturityTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityTime";
  FIX::DerivativeMaturityTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TZTIMEONLY const &","FIX::DerivativeMaturityTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TZTIMEONLY const &","FIX::DerivativeMaturityTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::DerivativeMaturityTime *)new FIX::DerivativeMaturityTime((FIX::TZTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeMaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeMaturityTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeMaturityTime.new", 
    "    DerivativeMaturityTime.new()\n"
    "    DerivativeMaturityTime.new(FIX::TZTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMaturityTime(FIX::DerivativeMaturityTime *arg1) {
    delete arg1;
}

swig_class SwigClassExpireTime;

SWIGINTERN VALUE
_wrap_new_ExpireTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  FIX::ExpireTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExpireTime *)new FIX::ExpireTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ExpireTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  FIX::ExpireTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ExpireTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::ExpireTime *)new FIX::ExpireTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ExpireTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  FIX::ExpireTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ExpireTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ExpireTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::ExpireTime *)new FIX::ExpireTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExpireTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExpireTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExpireTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExpireTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  FIX::ExpireTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ExpireTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ExpireTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ExpireTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::ExpireTime *)new FIX::ExpireTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExpireTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExpireTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpireTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ExpireTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExpireTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ExpireTime.new", 
    "    ExpireTime.new()\n"
    "    ExpireTime.new(bool showMilliseconds)\n"
    "    ExpireTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    ExpireTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpireTime(FIX::ExpireTime *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingFactor;

SWIGINTERN VALUE
_wrap_new_UnderlyingFactor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFactor";
  FIX::UnderlyingFactor *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingFactor *)new FIX::UnderlyingFactor();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingFactor_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingFactor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingFactor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingFactor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFactor";
  FIX::UnderlyingFactor *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::UnderlyingFactor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::UnderlyingFactor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::UnderlyingFactor *)new FIX::UnderlyingFactor((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingFactor(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingFactor__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFactor__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingFactor.new", 
    "    UnderlyingFactor.new()\n"
    "    UnderlyingFactor.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFactor(FIX::UnderlyingFactor *arg1) {
    delete arg1;
}

swig_class SwigClassOrigOrdModTime;

SWIGINTERN VALUE
_wrap_new_OrigOrdModTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  FIX::OrigOrdModTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OrigOrdModTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  FIX::OrigOrdModTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::OrigOrdModTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OrigOrdModTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  FIX::OrigOrdModTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OrigOrdModTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OrigOrdModTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigOrdModTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigOrdModTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigOrdModTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigOrdModTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  FIX::OrigOrdModTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OrigOrdModTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OrigOrdModTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::OrigOrdModTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigOrdModTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigOrdModTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigOrdModTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_OrigOrdModTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrigOrdModTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "OrigOrdModTime.new", 
    "    OrigOrdModTime.new()\n"
    "    OrigOrdModTime.new(bool showMilliseconds)\n"
    "    OrigOrdModTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    OrigOrdModTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigOrdModTime(FIX::OrigOrdModTime *arg1) {
    delete arg1;
}

swig_class SwigClassNoTrdRepIndicators;

SWIGINTERN VALUE
_wrap_new_NoTrdRepIndicators__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRepIndicators";
  FIX::NoTrdRepIndicators *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTrdRepIndicators *)new FIX::NoTrdRepIndicators();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTrdRepIndicators_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTrdRepIndicators_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTrdRepIndicators);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTrdRepIndicators__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRepIndicators";
  FIX::NoTrdRepIndicators *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTrdRepIndicators", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTrdRepIndicators", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTrdRepIndicators *)new FIX::NoTrdRepIndicators((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTrdRepIndicators(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTrdRepIndicators__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTrdRepIndicators__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTrdRepIndicators.new", 
    "    NoTrdRepIndicators.new()\n"
    "    NoTrdRepIndicators.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTrdRepIndicators(FIX::NoTrdRepIndicators *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeMaturityDate;

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityDate";
  FIX::DerivativeMaturityDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeMaturityDate *)new FIX::DerivativeMaturityDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeMaturityDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeMaturityDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeMaturityDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityDate";
  FIX::DerivativeMaturityDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::DerivativeMaturityDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::DerivativeMaturityDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::DerivativeMaturityDate *)new FIX::DerivativeMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeMaturityDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeMaturityDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMaturityDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeMaturityDate.new", 
    "    DerivativeMaturityDate.new()\n"
    "    DerivativeMaturityDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMaturityDate(FIX::DerivativeMaturityDate *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeCFICode;

SWIGINTERN VALUE
_wrap_new_DerivativeCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCFICode";
  FIX::DerivativeCFICode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeCFICode *)new FIX::DerivativeCFICode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeCFICode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeCFICode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeCFICode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeCFICode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCFICode";
  FIX::DerivativeCFICode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeCFICode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeCFICode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeCFICode *)new FIX::DerivativeCFICode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeCFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeCFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeCFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeCFICode.new", 
    "    DerivativeCFICode.new()\n"
    "    DerivativeCFICode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeCFICode(FIX::DerivativeCFICode *arg1) {
    delete arg1;
}

swig_class SwigClassNested2PartySubIDType;

SWIGINTERN VALUE
_wrap_new_Nested2PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubIDType";
  FIX::Nested2PartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested2PartySubIDType *)new FIX::Nested2PartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested2PartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested2PartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested2PartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested2PartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubIDType";
  FIX::Nested2PartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Nested2PartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Nested2PartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Nested2PartySubIDType *)new FIX::Nested2PartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested2PartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested2PartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested2PartySubIDType.new", 
    "    Nested2PartySubIDType.new()\n"
    "    Nested2PartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartySubIDType(FIX::Nested2PartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassLegIOIQty;

SWIGINTERN VALUE
_wrap_new_LegIOIQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegIOIQty";
  FIX::LegIOIQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegIOIQty *)new FIX::LegIOIQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegIOIQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegIOIQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegIOIQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegIOIQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIOIQty";
  FIX::LegIOIQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegIOIQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegIOIQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegIOIQty *)new FIX::LegIOIQty((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegIOIQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegIOIQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIOIQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegIOIQty.new", 
    "    LegIOIQty.new()\n"
    "    LegIOIQty.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIOIQty(FIX::LegIOIQty *arg1) {
    delete arg1;
}

swig_class SwigClassExpireDate;

SWIGINTERN VALUE
_wrap_new_ExpireDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExpireDate";
  FIX::ExpireDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExpireDate *)new FIX::ExpireDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExpireDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExpireDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExpireDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExpireDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireDate";
  FIX::ExpireDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::ExpireDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::ExpireDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::ExpireDate *)new FIX::ExpireDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExpireDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExpireDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpireDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExpireDate.new", 
    "    ExpireDate.new()\n"
    "    ExpireDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpireDate(FIX::ExpireDate *arg1) {
    delete arg1;
}

swig_class SwigClassNoMatchRules;

SWIGINTERN VALUE
_wrap_new_NoMatchRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoMatchRules";
  FIX::NoMatchRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoMatchRules *)new FIX::NoMatchRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoMatchRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoMatchRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoMatchRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoMatchRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMatchRules";
  FIX::NoMatchRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoMatchRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoMatchRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoMatchRules *)new FIX::NoMatchRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoMatchRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoMatchRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMatchRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoMatchRules.new", 
    "    NoMatchRules.new()\n"
    "    NoMatchRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMatchRules(FIX::NoMatchRules *arg1) {
    delete arg1;
}

swig_class SwigClassApplEndSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplEndSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplEndSeqNum";
  FIX::ApplEndSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplEndSeqNum *)new FIX::ApplEndSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplEndSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplEndSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplEndSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplEndSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplEndSeqNum";
  FIX::ApplEndSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::ApplEndSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::ApplEndSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::ApplEndSeqNum *)new FIX::ApplEndSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplEndSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplEndSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplEndSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplEndSeqNum.new", 
    "    ApplEndSeqNum.new()\n"
    "    ApplEndSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplEndSeqNum(FIX::ApplEndSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassEventPx;

SWIGINTERN VALUE
_wrap_new_EventPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EventPx";
  FIX::EventPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EventPx *)new FIX::EventPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EventPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EventPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EventPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EventPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventPx";
  FIX::EventPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::EventPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::EventPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::EventPx *)new FIX::EventPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EventPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EventPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EventPx.new", 
    "    EventPx.new()\n"
    "    EventPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EventPx(FIX::EventPx *arg1) {
    delete arg1;
}

swig_class SwigClassAsgnRptID;

SWIGINTERN VALUE
_wrap_new_AsgnRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AsgnRptID";
  FIX::AsgnRptID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AsgnRptID *)new FIX::AsgnRptID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AsgnRptID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AsgnRptID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AsgnRptID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AsgnRptID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AsgnRptID";
  FIX::AsgnRptID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AsgnRptID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AsgnRptID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AsgnRptID *)new FIX::AsgnRptID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AsgnRptID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AsgnRptID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AsgnRptID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AsgnRptID.new", 
    "    AsgnRptID.new()\n"
    "    AsgnRptID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AsgnRptID(FIX::AsgnRptID *arg1) {
    delete arg1;
}

swig_class SwigClassTimeInForce;

SWIGINTERN VALUE
_wrap_new_TimeInForce__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TimeInForce";
  FIX::TimeInForce *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TimeInForce *)new FIX::TimeInForce();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TimeInForce_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TimeInForce_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TimeInForce);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TimeInForce__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeInForce";
  FIX::TimeInForce *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TimeInForce", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TimeInForce", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TimeInForce *)new FIX::TimeInForce((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TimeInForce(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TimeInForce__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeInForce__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TimeInForce.new", 
    "    TimeInForce.new()\n"
    "    TimeInForce.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeInForce(FIX::TimeInForce *arg1) {
    delete arg1;
}

swig_class SwigClassLowPx;

SWIGINTERN VALUE
_wrap_new_LowPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LowPx";
  FIX::LowPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LowPx *)new FIX::LowPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LowPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LowPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LowPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LowPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LowPx";
  FIX::LowPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LowPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LowPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LowPx *)new FIX::LowPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LowPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LowPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LowPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LowPx.new", 
    "    LowPx.new()\n"
    "    LowPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LowPx(FIX::LowPx *arg1) {
    delete arg1;
}

swig_class SwigClassIOIQualifier;

SWIGINTERN VALUE
_wrap_new_IOIQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIQualifier";
  FIX::IOIQualifier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIQualifier *)new FIX::IOIQualifier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIQualifier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIQualifier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIQualifier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIQualifier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQualifier";
  FIX::IOIQualifier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::IOIQualifier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::IOIQualifier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::IOIQualifier *)new FIX::IOIQualifier((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIQualifier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIQualifier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIQualifier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIQualifier.new", 
    "    IOIQualifier.new()\n"
    "    IOIQualifier.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIQualifier(FIX::IOIQualifier *arg1) {
    delete arg1;
}

swig_class SwigClassWaveNo;

SWIGINTERN VALUE
_wrap_new_WaveNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::WaveNo";
  FIX::WaveNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::WaveNo *)new FIX::WaveNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_WaveNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_WaveNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__WaveNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_WaveNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WaveNo";
  FIX::WaveNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::WaveNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::WaveNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::WaveNo *)new FIX::WaveNo((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_WaveNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_WaveNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WaveNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "WaveNo.new", 
    "    WaveNo.new()\n"
    "    WaveNo.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_WaveNo(FIX::WaveNo *arg1) {
    delete arg1;
}

swig_class SwigClassStrikePriceBoundaryMethod;

SWIGINTERN VALUE
_wrap_new_StrikePriceBoundaryMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryMethod";
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikePriceBoundaryMethod *)new FIX::StrikePriceBoundaryMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikePriceBoundaryMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikePriceBoundaryMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikePriceBoundaryMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikePriceBoundaryMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryMethod";
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StrikePriceBoundaryMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StrikePriceBoundaryMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StrikePriceBoundaryMethod *)new FIX::StrikePriceBoundaryMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikePriceBoundaryMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikePriceBoundaryMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePriceBoundaryMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikePriceBoundaryMethod.new", 
    "    StrikePriceBoundaryMethod.new()\n"
    "    StrikePriceBoundaryMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePriceBoundaryMethod(FIX::StrikePriceBoundaryMethod *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeIssueDate;

SWIGINTERN VALUE
_wrap_new_DerivativeIssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssueDate";
  FIX::DerivativeIssueDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeIssueDate *)new FIX::DerivativeIssueDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeIssueDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeIssueDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeIssueDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeIssueDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssueDate";
  FIX::DerivativeIssueDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::DerivativeIssueDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::DerivativeIssueDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::DerivativeIssueDate *)new FIX::DerivativeIssueDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeIssueDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeIssueDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeIssueDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeIssueDate.new", 
    "    DerivativeIssueDate.new()\n"
    "    DerivativeIssueDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeIssueDate(FIX::DerivativeIssueDate *arg1) {
    delete arg1;
}

swig_class SwigClassMiscFeeType;

SWIGINTERN VALUE
_wrap_new_MiscFeeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeType";
  FIX::MiscFeeType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MiscFeeType *)new FIX::MiscFeeType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MiscFeeType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MiscFeeType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MiscFeeType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MiscFeeType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeType";
  FIX::MiscFeeType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MiscFeeType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MiscFeeType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MiscFeeType *)new FIX::MiscFeeType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MiscFeeType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MiscFeeType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MiscFeeType.new", 
    "    MiscFeeType.new()\n"
    "    MiscFeeType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeType(FIX::MiscFeeType *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteID;

SWIGINTERN VALUE
_wrap_new_QuoteID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteID";
  FIX::QuoteID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteID *)new FIX::QuoteID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteID";
  FIX::QuoteID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteID *)new FIX::QuoteID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteID.new", 
    "    QuoteID.new()\n"
    "    QuoteID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteID(FIX::QuoteID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyIDSource";
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrumentPartyIDSource *)new FIX::DerivativeInstrumentPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrumentPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrumentPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyIDSource";
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeInstrumentPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeInstrumentPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeInstrumentPartyIDSource *)new FIX::DerivativeInstrumentPartyIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrumentPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrumentPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrumentPartyIDSource.new", 
    "    DerivativeInstrumentPartyIDSource.new()\n"
    "    DerivativeInstrumentPartyIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartyIDSource(FIX::DerivativeInstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassSettlObligID;

SWIGINTERN VALUE
_wrap_new_SettlObligID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlObligID";
  FIX::SettlObligID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlObligID *)new FIX::SettlObligID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlObligID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlObligID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlObligID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlObligID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligID";
  FIX::SettlObligID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlObligID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlObligID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlObligID *)new FIX::SettlObligID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlObligID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlObligID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlObligID.new", 
    "    SettlObligID.new()\n"
    "    SettlObligID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligID(FIX::SettlObligID *arg1) {
    delete arg1;
}

swig_class SwigClassInstrAttribValue;

SWIGINTERN VALUE
_wrap_new_InstrAttribValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribValue";
  FIX::InstrAttribValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrAttribValue *)new FIX::InstrAttribValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrAttribValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrAttribValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrAttribValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrAttribValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribValue";
  FIX::InstrAttribValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::InstrAttribValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::InstrAttribValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::InstrAttribValue *)new FIX::InstrAttribValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrAttribValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrAttribValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrAttribValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrAttribValue.new", 
    "    InstrAttribValue.new()\n"
    "    InstrAttribValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrAttribValue(FIX::InstrAttribValue *arg1) {
    delete arg1;
}

swig_class SwigClassLiquidityValue;

SWIGINTERN VALUE
_wrap_new_LiquidityValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LiquidityValue";
  FIX::LiquidityValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LiquidityValue *)new FIX::LiquidityValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LiquidityValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LiquidityValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LiquidityValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LiquidityValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityValue";
  FIX::LiquidityValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::LiquidityValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::LiquidityValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::LiquidityValue *)new FIX::LiquidityValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LiquidityValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LiquidityValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LiquidityValue.new", 
    "    LiquidityValue.new()\n"
    "    LiquidityValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityValue(FIX::LiquidityValue *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_SecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityIDSource";
  FIX::SecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityIDSource *)new FIX::SecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityIDSource";
  FIX::SecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityIDSource *)new FIX::SecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityIDSource.new", 
    "    SecurityIDSource.new()\n"
    "    SecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityIDSource(FIX::SecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassNewsRefType;

SWIGINTERN VALUE
_wrap_new_NewsRefType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NewsRefType";
  FIX::NewsRefType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NewsRefType *)new FIX::NewsRefType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NewsRefType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NewsRefType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NewsRefType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NewsRefType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsRefType";
  FIX::NewsRefType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NewsRefType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NewsRefType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NewsRefType *)new FIX::NewsRefType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NewsRefType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NewsRefType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsRefType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NewsRefType.new", 
    "    NewsRefType.new()\n"
    "    NewsRefType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsRefType(FIX::NewsRefType *arg1) {
    delete arg1;
}

swig_class SwigClassNoOfLegUnderlyings;

SWIGINTERN VALUE
_wrap_new_NoOfLegUnderlyings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoOfLegUnderlyings";
  FIX::NoOfLegUnderlyings *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoOfLegUnderlyings *)new FIX::NoOfLegUnderlyings();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoOfLegUnderlyings_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoOfLegUnderlyings_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoOfLegUnderlyings);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoOfLegUnderlyings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOfLegUnderlyings";
  FIX::NoOfLegUnderlyings *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoOfLegUnderlyings", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoOfLegUnderlyings", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoOfLegUnderlyings *)new FIX::NoOfLegUnderlyings((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoOfLegUnderlyings(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoOfLegUnderlyings__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOfLegUnderlyings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoOfLegUnderlyings.new", 
    "    NoOfLegUnderlyings.new()\n"
    "    NoOfLegUnderlyings.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOfLegUnderlyings(FIX::NoOfLegUnderlyings *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeEncodedSecurityDesc;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDesc";
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeEncodedSecurityDesc *)new FIX::DerivativeEncodedSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeEncodedSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeEncodedSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDesc";
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::DerivativeEncodedSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::DerivativeEncodedSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::DerivativeEncodedSecurityDesc *)new FIX::DerivativeEncodedSecurityDesc((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeEncodedSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeEncodedSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeEncodedSecurityDesc.new", 
    "    DerivativeEncodedSecurityDesc.new()\n"
    "    DerivativeEncodedSecurityDesc.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedSecurityDesc(FIX::DerivativeEncodedSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerOrderType;

SWIGINTERN VALUE
_wrap_new_TriggerOrderType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerOrderType";
  FIX::TriggerOrderType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerOrderType *)new FIX::TriggerOrderType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerOrderType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerOrderType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerOrderType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerOrderType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerOrderType";
  FIX::TriggerOrderType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TriggerOrderType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TriggerOrderType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TriggerOrderType *)new FIX::TriggerOrderType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerOrderType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerOrderType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerOrderType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerOrderType.new", 
    "    TriggerOrderType.new()\n"
    "    TriggerOrderType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerOrderType(FIX::TriggerOrderType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingDirtyPrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingDirtyPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDirtyPrice";
  FIX::UnderlyingDirtyPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingDirtyPrice *)new FIX::UnderlyingDirtyPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingDirtyPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingDirtyPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingDirtyPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingDirtyPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDirtyPrice";
  FIX::UnderlyingDirtyPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingDirtyPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingDirtyPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingDirtyPrice *)new FIX::UnderlyingDirtyPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingDirtyPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingDirtyPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingDirtyPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingDirtyPrice.new", 
    "    UnderlyingDirtyPrice.new()\n"
    "    UnderlyingDirtyPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingDirtyPrice(FIX::UnderlyingDirtyPrice *arg1) {
    delete arg1;
}

swig_class SwigClassCrossType;

SWIGINTERN VALUE
_wrap_new_CrossType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CrossType";
  FIX::CrossType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CrossType *)new FIX::CrossType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CrossType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CrossType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CrossType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CrossType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossType";
  FIX::CrossType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CrossType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CrossType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CrossType *)new FIX::CrossType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CrossType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CrossType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CrossType.new", 
    "    CrossType.new()\n"
    "    CrossType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossType(FIX::CrossType *arg1) {
    delete arg1;
}

swig_class SwigClassRepoCollateralSecurityType;

SWIGINTERN VALUE
_wrap_new_RepoCollateralSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RepoCollateralSecurityType";
  FIX::RepoCollateralSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RepoCollateralSecurityType *)new FIX::RepoCollateralSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RepoCollateralSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RepoCollateralSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RepoCollateralSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RepoCollateralSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepoCollateralSecurityType";
  FIX::RepoCollateralSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RepoCollateralSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RepoCollateralSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RepoCollateralSecurityType *)new FIX::RepoCollateralSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RepoCollateralSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RepoCollateralSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepoCollateralSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RepoCollateralSecurityType.new", 
    "    RepoCollateralSecurityType.new()\n"
    "    RepoCollateralSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RepoCollateralSecurityType(FIX::RepoCollateralSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassPassword;

SWIGINTERN VALUE
_wrap_new_Password__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Password";
  FIX::Password *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Password *)new FIX::Password();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Password_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Password_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Password);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Password__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Password";
  FIX::Password *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Password", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Password", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Password *)new FIX::Password((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Password(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Password__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Password__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Password.new", 
    "    Password.new()\n"
    "    Password.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Password(FIX::Password *arg1) {
    delete arg1;
}

swig_class SwigClassOpenCloseSettleFlag;

SWIGINTERN VALUE
_wrap_new_OpenCloseSettleFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettleFlag";
  FIX::OpenCloseSettleFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OpenCloseSettleFlag *)new FIX::OpenCloseSettleFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OpenCloseSettleFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OpenCloseSettleFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OpenCloseSettleFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OpenCloseSettleFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLEVALUESTRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettleFlag";
  FIX::OpenCloseSettleFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLEVALUESTRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLEVALUESTRING const &","FIX::OpenCloseSettleFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLEVALUESTRING const &","FIX::OpenCloseSettleFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLEVALUESTRING * >(argp1);
  result = (FIX::OpenCloseSettleFlag *)new FIX::OpenCloseSettleFlag((FIX::MULTIPLEVALUESTRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OpenCloseSettleFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OpenCloseSettleFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLEVALUESTRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenCloseSettleFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OpenCloseSettleFlag.new", 
    "    OpenCloseSettleFlag.new()\n"
    "    OpenCloseSettleFlag.new(FIX::MULTIPLEVALUESTRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenCloseSettleFlag(FIX::OpenCloseSettleFlag *arg1) {
    delete arg1;
}

swig_class SwigClassSubject;

SWIGINTERN VALUE
_wrap_new_Subject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Subject";
  FIX::Subject *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Subject *)new FIX::Subject();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Subject_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Subject_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Subject);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Subject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Subject";
  FIX::Subject *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Subject", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Subject", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Subject *)new FIX::Subject((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Subject(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Subject__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Subject__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Subject.new", 
    "    Subject.new()\n"
    "    Subject.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Subject(FIX::Subject *arg1) {
    delete arg1;
}

swig_class SwigClassRefApplReqID;

SWIGINTERN VALUE
_wrap_new_RefApplReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefApplReqID";
  FIX::RefApplReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefApplReqID *)new FIX::RefApplReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefApplReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefApplReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefApplReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefApplReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplReqID";
  FIX::RefApplReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefApplReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefApplReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefApplReqID *)new FIX::RefApplReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefApplReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefApplReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefApplReqID.new", 
    "    RefApplReqID.new()\n"
    "    RefApplReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplReqID(FIX::RefApplReqID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingEndValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingEndValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndValue";
  FIX::UnderlyingEndValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingEndValue *)new FIX::UnderlyingEndValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingEndValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingEndValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingEndValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingEndValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndValue";
  FIX::UnderlyingEndValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingEndValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingEndValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingEndValue *)new FIX::UnderlyingEndValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingEndValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingEndValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingEndValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingEndValue.new", 
    "    UnderlyingEndValue.new()\n"
    "    UnderlyingEndValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingEndValue(FIX::UnderlyingEndValue *arg1) {
    delete arg1;
}

swig_class SwigClassNewSeqNo;

SWIGINTERN VALUE
_wrap_new_NewSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NewSeqNo";
  FIX::NewSeqNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NewSeqNo *)new FIX::NewSeqNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NewSeqNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NewSeqNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NewSeqNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NewSeqNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewSeqNo";
  FIX::NewSeqNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::NewSeqNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::NewSeqNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::NewSeqNo *)new FIX::NewSeqNo((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NewSeqNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NewSeqNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewSeqNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NewSeqNo.new", 
    "    NewSeqNo.new()\n"
    "    NewSeqNo.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NewSeqNo(FIX::NewSeqNo *arg1) {
    delete arg1;
}

swig_class SwigClassOrigTradeHandlingInstr;

SWIGINTERN VALUE
_wrap_new_OrigTradeHandlingInstr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeHandlingInstr";
  FIX::OrigTradeHandlingInstr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigTradeHandlingInstr *)new FIX::OrigTradeHandlingInstr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigTradeHandlingInstr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigTradeHandlingInstr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigTradeHandlingInstr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigTradeHandlingInstr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeHandlingInstr";
  FIX::OrigTradeHandlingInstr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OrigTradeHandlingInstr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OrigTradeHandlingInstr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OrigTradeHandlingInstr *)new FIX::OrigTradeHandlingInstr((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigTradeHandlingInstr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigTradeHandlingInstr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTradeHandlingInstr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigTradeHandlingInstr.new", 
    "    OrigTradeHandlingInstr.new()\n"
    "    OrigTradeHandlingInstr.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTradeHandlingInstr(FIX::OrigTradeHandlingInstr *arg1) {
    delete arg1;
}

swig_class SwigClassDisplayHighQty;

SWIGINTERN VALUE
_wrap_new_DisplayHighQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DisplayHighQty";
  FIX::DisplayHighQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DisplayHighQty *)new FIX::DisplayHighQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DisplayHighQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DisplayHighQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DisplayHighQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DisplayHighQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayHighQty";
  FIX::DisplayHighQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DisplayHighQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DisplayHighQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DisplayHighQty *)new FIX::DisplayHighQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DisplayHighQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DisplayHighQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayHighQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DisplayHighQty.new", 
    "    DisplayHighQty.new()\n"
    "    DisplayHighQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayHighQty(FIX::DisplayHighQty *arg1) {
    delete arg1;
}

swig_class SwigClassMDBookType;

SWIGINTERN VALUE
_wrap_new_MDBookType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDBookType";
  FIX::MDBookType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDBookType *)new FIX::MDBookType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDBookType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDBookType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDBookType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDBookType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDBookType";
  FIX::MDBookType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDBookType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDBookType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDBookType *)new FIX::MDBookType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDBookType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDBookType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDBookType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDBookType.new", 
    "    MDBookType.new()\n"
    "    MDBookType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDBookType(FIX::MDBookType *arg1) {
    delete arg1;
}

swig_class SwigClassMarginExcess;

SWIGINTERN VALUE
_wrap_new_MarginExcess__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarginExcess";
  FIX::MarginExcess *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarginExcess *)new FIX::MarginExcess();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarginExcess_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarginExcess_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarginExcess);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarginExcess__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarginExcess";
  FIX::MarginExcess *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::MarginExcess", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::MarginExcess", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::MarginExcess *)new FIX::MarginExcess((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarginExcess(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarginExcess__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarginExcess__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarginExcess.new", 
    "    MarginExcess.new()\n"
    "    MarginExcess.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarginExcess(FIX::MarginExcess *arg1) {
    delete arg1;
}

swig_class SwigClassBasisPxType;

SWIGINTERN VALUE
_wrap_new_BasisPxType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BasisPxType";
  FIX::BasisPxType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BasisPxType *)new FIX::BasisPxType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BasisPxType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BasisPxType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BasisPxType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BasisPxType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisPxType";
  FIX::BasisPxType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::BasisPxType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::BasisPxType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::BasisPxType *)new FIX::BasisPxType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BasisPxType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BasisPxType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BasisPxType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BasisPxType.new", 
    "    BasisPxType.new()\n"
    "    BasisPxType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BasisPxType(FIX::BasisPxType *arg1) {
    delete arg1;
}

swig_class SwigClassDlvyInst;

SWIGINTERN VALUE
_wrap_new_DlvyInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DlvyInst";
  FIX::DlvyInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DlvyInst *)new FIX::DlvyInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DlvyInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DlvyInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DlvyInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DlvyInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DlvyInst";
  FIX::DlvyInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DlvyInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DlvyInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DlvyInst *)new FIX::DlvyInst((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DlvyInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DlvyInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DlvyInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DlvyInst.new", 
    "    DlvyInst.new()\n"
    "    DlvyInst.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DlvyInst(FIX::DlvyInst *arg1) {
    delete arg1;
}

swig_class SwigClassComplianceID;

SWIGINTERN VALUE
_wrap_new_ComplianceID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplianceID";
  FIX::ComplianceID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplianceID *)new FIX::ComplianceID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplianceID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplianceID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplianceID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplianceID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplianceID";
  FIX::ComplianceID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ComplianceID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ComplianceID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ComplianceID *)new FIX::ComplianceID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplianceID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplianceID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplianceID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplianceID.new", 
    "    ComplianceID.new()\n"
    "    ComplianceID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplianceID(FIX::ComplianceID *arg1) {
    delete arg1;
}

swig_class SwigClassEmailThreadID;

SWIGINTERN VALUE
_wrap_new_EmailThreadID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EmailThreadID";
  FIX::EmailThreadID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EmailThreadID *)new FIX::EmailThreadID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EmailThreadID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EmailThreadID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EmailThreadID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EmailThreadID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EmailThreadID";
  FIX::EmailThreadID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::EmailThreadID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::EmailThreadID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::EmailThreadID *)new FIX::EmailThreadID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EmailThreadID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EmailThreadID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EmailThreadID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EmailThreadID.new", 
    "    EmailThreadID.new()\n"
    "    EmailThreadID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EmailThreadID(FIX::EmailThreadID *arg1) {
    delete arg1;
}

swig_class SwigClassContAmtCurr;

SWIGINTERN VALUE
_wrap_new_ContAmtCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContAmtCurr";
  FIX::ContAmtCurr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContAmtCurr *)new FIX::ContAmtCurr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContAmtCurr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContAmtCurr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContAmtCurr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContAmtCurr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtCurr";
  FIX::ContAmtCurr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::ContAmtCurr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::ContAmtCurr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::ContAmtCurr *)new FIX::ContAmtCurr((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContAmtCurr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContAmtCurr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContAmtCurr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContAmtCurr.new", 
    "    ContAmtCurr.new()\n"
    "    ContAmtCurr.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContAmtCurr(FIX::ContAmtCurr *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventType;

SWIGINTERN VALUE
_wrap_new_ComplexEventType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventType";
  FIX::ComplexEventType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventType *)new FIX::ComplexEventType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventType";
  FIX::ComplexEventType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ComplexEventType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ComplexEventType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ComplexEventType *)new FIX::ComplexEventType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventType.new", 
    "    ComplexEventType.new()\n"
    "    ComplexEventType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventType(FIX::ComplexEventType *arg1) {
    delete arg1;
}

swig_class SwigClassMassActionResponse;

SWIGINTERN VALUE
_wrap_new_MassActionResponse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassActionResponse";
  FIX::MassActionResponse *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassActionResponse *)new FIX::MassActionResponse();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassActionResponse_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassActionResponse_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassActionResponse);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassActionResponse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionResponse";
  FIX::MassActionResponse *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MassActionResponse", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MassActionResponse", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MassActionResponse *)new FIX::MassActionResponse((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassActionResponse(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassActionResponse__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionResponse__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassActionResponse.new", 
    "    MassActionResponse.new()\n"
    "    MassActionResponse.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionResponse(FIX::MassActionResponse *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingIssueDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingIssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssueDate";
  FIX::UnderlyingIssueDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingIssueDate *)new FIX::UnderlyingIssueDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingIssueDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingIssueDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingIssueDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingIssueDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssueDate";
  FIX::UnderlyingIssueDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::UnderlyingIssueDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::UnderlyingIssueDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::UnderlyingIssueDate *)new FIX::UnderlyingIssueDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingIssueDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingIssueDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingIssueDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingIssueDate.new", 
    "    UnderlyingIssueDate.new()\n"
    "    UnderlyingIssueDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingIssueDate(FIX::UnderlyingIssueDate *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityRequestType;

SWIGINTERN VALUE
_wrap_new_SecurityRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestType";
  FIX::SecurityRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityRequestType *)new FIX::SecurityRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestType";
  FIX::SecurityRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityRequestType *)new FIX::SecurityRequestType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityRequestType.new", 
    "    SecurityRequestType.new()\n"
    "    SecurityRequestType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityRequestType(FIX::SecurityRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassAllocInterestAtMaturity;

SWIGINTERN VALUE
_wrap_new_AllocInterestAtMaturity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocInterestAtMaturity";
  FIX::AllocInterestAtMaturity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocInterestAtMaturity *)new FIX::AllocInterestAtMaturity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocInterestAtMaturity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocInterestAtMaturity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocInterestAtMaturity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocInterestAtMaturity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocInterestAtMaturity";
  FIX::AllocInterestAtMaturity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::AllocInterestAtMaturity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::AllocInterestAtMaturity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::AllocInterestAtMaturity *)new FIX::AllocInterestAtMaturity((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocInterestAtMaturity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocInterestAtMaturity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocInterestAtMaturity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocInterestAtMaturity.new", 
    "    AllocInterestAtMaturity.new()\n"
    "    AllocInterestAtMaturity.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocInterestAtMaturity(FIX::AllocInterestAtMaturity *arg1) {
    delete arg1;
}

swig_class SwigClassListRejectReason;

SWIGINTERN VALUE
_wrap_new_ListRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListRejectReason";
  FIX::ListRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListRejectReason *)new FIX::ListRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListRejectReason";
  FIX::ListRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ListRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ListRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ListRejectReason *)new FIX::ListRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListRejectReason.new", 
    "    ListRejectReason.new()\n"
    "    ListRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListRejectReason(FIX::ListRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassDeskType;

SWIGINTERN VALUE
_wrap_new_DeskType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeskType";
  FIX::DeskType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeskType *)new FIX::DeskType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeskType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeskType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeskType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeskType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskType";
  FIX::DeskType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DeskType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DeskType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DeskType *)new FIX::DeskType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeskType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeskType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeskType.new", 
    "    DeskType.new()\n"
    "    DeskType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskType(FIX::DeskType *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryTradeReportID;

SWIGINTERN VALUE
_wrap_new_SecondaryTradeReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportID";
  FIX::SecondaryTradeReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryTradeReportID *)new FIX::SecondaryTradeReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryTradeReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryTradeReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryTradeReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryTradeReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportID";
  FIX::SecondaryTradeReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryTradeReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryTradeReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryTradeReportID *)new FIX::SecondaryTradeReportID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryTradeReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryTradeReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradeReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryTradeReportID.new", 
    "    SecondaryTradeReportID.new()\n"
    "    SecondaryTradeReportID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradeReportID(FIX::SecondaryTradeReportID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlType;

SWIGINTERN VALUE
_wrap_new_SettlType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlType";
  FIX::SettlType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlType *)new FIX::SettlType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlType";
  FIX::SettlType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlType *)new FIX::SettlType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlType.new", 
    "    SettlType.new()\n"
    "    SettlType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlType(FIX::SettlType *arg1) {
    delete arg1;
}

swig_class SwigClassOpenClose;

SWIGINTERN VALUE
_wrap_new_OpenClose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OpenClose";
  FIX::OpenClose *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OpenClose *)new FIX::OpenClose();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OpenClose_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OpenClose_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OpenClose);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OpenClose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenClose";
  FIX::OpenClose *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OpenClose", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OpenClose", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OpenClose *)new FIX::OpenClose((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OpenClose(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OpenClose__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenClose__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OpenClose.new", 
    "    OpenClose.new()\n"
    "    OpenClose.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenClose(FIX::OpenClose *arg1) {
    delete arg1;
}

swig_class SwigClassContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_ContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplierUnit";
  FIX::ContractMultiplierUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContractMultiplierUnit *)new FIX::ContractMultiplierUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContractMultiplierUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContractMultiplierUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContractMultiplierUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContractMultiplierUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplierUnit";
  FIX::ContractMultiplierUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ContractMultiplierUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ContractMultiplierUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ContractMultiplierUnit *)new FIX::ContractMultiplierUnit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContractMultiplierUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContractMultiplierUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContractMultiplierUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContractMultiplierUnit.new", 
    "    ContractMultiplierUnit.new()\n"
    "    ContractMultiplierUnit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContractMultiplierUnit(FIX::ContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryLowLimitPrice;

SWIGINTERN VALUE
_wrap_new_SecondaryLowLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryLowLimitPrice";
  FIX::SecondaryLowLimitPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryLowLimitPrice *)new FIX::SecondaryLowLimitPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryLowLimitPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryLowLimitPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryLowLimitPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryLowLimitPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryLowLimitPrice";
  FIX::SecondaryLowLimitPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::SecondaryLowLimitPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::SecondaryLowLimitPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::SecondaryLowLimitPrice *)new FIX::SecondaryLowLimitPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryLowLimitPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryLowLimitPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryLowLimitPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryLowLimitPrice.new", 
    "    SecondaryLowLimitPrice.new()\n"
    "    SecondaryLowLimitPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryLowLimitPrice(FIX::SecondaryLowLimitPrice *arg1) {
    delete arg1;
}

swig_class SwigClassExpQty;

SWIGINTERN VALUE
_wrap_new_ExpQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExpQty";
  FIX::ExpQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExpQty *)new FIX::ExpQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExpQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExpQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExpQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExpQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpQty";
  FIX::ExpQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::ExpQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::ExpQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::ExpQty *)new FIX::ExpQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExpQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExpQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExpQty.new", 
    "    ExpQty.new()\n"
    "    ExpQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpQty(FIX::ExpQty *arg1) {
    delete arg1;
}

swig_class SwigClassNetworkRequestID;

SWIGINTERN VALUE
_wrap_new_NetworkRequestID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestID";
  FIX::NetworkRequestID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetworkRequestID *)new FIX::NetworkRequestID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetworkRequestID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetworkRequestID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetworkRequestID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetworkRequestID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestID";
  FIX::NetworkRequestID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NetworkRequestID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NetworkRequestID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NetworkRequestID *)new FIX::NetworkRequestID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetworkRequestID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetworkRequestID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkRequestID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetworkRequestID.new", 
    "    NetworkRequestID.new()\n"
    "    NetworkRequestID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkRequestID(FIX::NetworkRequestID *arg1) {
    delete arg1;
}

swig_class SwigClassTrdType;

SWIGINTERN VALUE
_wrap_new_TrdType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdType";
  FIX::TrdType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdType *)new FIX::TrdType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdType";
  FIX::TrdType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TrdType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TrdType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TrdType *)new FIX::TrdType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdType.new", 
    "    TrdType.new()\n"
    "    TrdType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdType(FIX::TrdType *arg1) {
    delete arg1;
}

swig_class SwigClassNoUnderlyings;

SWIGINTERN VALUE
_wrap_new_NoUnderlyings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyings";
  FIX::NoUnderlyings *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUnderlyings *)new FIX::NoUnderlyings();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUnderlyings_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUnderlyings_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUnderlyings);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUnderlyings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyings";
  FIX::NoUnderlyings *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUnderlyings", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUnderlyings", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUnderlyings *)new FIX::NoUnderlyings((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUnderlyings(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUnderlyings__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUnderlyings.new", 
    "    NoUnderlyings.new()\n"
    "    NoUnderlyings.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyings(FIX::NoUnderlyings *arg1) {
    delete arg1;
}

swig_class SwigClassMDMkt;

SWIGINTERN VALUE
_wrap_new_MDMkt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDMkt";
  FIX::MDMkt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDMkt *)new FIX::MDMkt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDMkt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDMkt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDMkt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDMkt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDMkt";
  FIX::MDMkt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::MDMkt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::MDMkt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::MDMkt *)new FIX::MDMkt((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDMkt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDMkt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDMkt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDMkt.new", 
    "    MDMkt.new()\n"
    "    MDMkt.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDMkt(FIX::MDMkt *arg1) {
    delete arg1;
}

swig_class SwigClassLastMkt;

SWIGINTERN VALUE
_wrap_new_LastMkt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastMkt";
  FIX::LastMkt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastMkt *)new FIX::LastMkt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastMkt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastMkt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastMkt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastMkt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastMkt";
  FIX::LastMkt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::LastMkt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::LastMkt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::LastMkt *)new FIX::LastMkt((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastMkt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastMkt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastMkt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastMkt.new", 
    "    LastMkt.new()\n"
    "    LastMkt.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastMkt(FIX::LastMkt *arg1) {
    delete arg1;
}

swig_class SwigClassRestructuringType;

SWIGINTERN VALUE
_wrap_new_RestructuringType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RestructuringType";
  FIX::RestructuringType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RestructuringType *)new FIX::RestructuringType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RestructuringType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RestructuringType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RestructuringType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RestructuringType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RestructuringType";
  FIX::RestructuringType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RestructuringType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RestructuringType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RestructuringType *)new FIX::RestructuringType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RestructuringType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RestructuringType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RestructuringType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RestructuringType.new", 
    "    RestructuringType.new()\n"
    "    RestructuringType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RestructuringType(FIX::RestructuringType *arg1) {
    delete arg1;
}

swig_class SwigClassNoStrikeRules;

SWIGINTERN VALUE
_wrap_new_NoStrikeRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoStrikeRules";
  FIX::NoStrikeRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoStrikeRules *)new FIX::NoStrikeRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoStrikeRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoStrikeRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoStrikeRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoStrikeRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrikeRules";
  FIX::NoStrikeRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoStrikeRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoStrikeRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoStrikeRules *)new FIX::NoStrikeRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoStrikeRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoStrikeRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStrikeRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoStrikeRules.new", 
    "    NoStrikeRules.new()\n"
    "    NoStrikeRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStrikeRules(FIX::NoStrikeRules *arg1) {
    delete arg1;
}

swig_class SwigClassListName;

SWIGINTERN VALUE
_wrap_new_ListName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListName";
  FIX::ListName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListName *)new FIX::ListName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListName";
  FIX::ListName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ListName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ListName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ListName *)new FIX::ListName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListName.new", 
    "    ListName.new()\n"
    "    ListName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListName(FIX::ListName *arg1) {
    delete arg1;
}

swig_class SwigClassProgRptReqs;

SWIGINTERN VALUE
_wrap_new_ProgRptReqs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ProgRptReqs";
  FIX::ProgRptReqs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ProgRptReqs *)new FIX::ProgRptReqs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ProgRptReqs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ProgRptReqs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ProgRptReqs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ProgRptReqs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProgRptReqs";
  FIX::ProgRptReqs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ProgRptReqs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ProgRptReqs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ProgRptReqs *)new FIX::ProgRptReqs((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ProgRptReqs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ProgRptReqs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProgRptReqs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ProgRptReqs.new", 
    "    ProgRptReqs.new()\n"
    "    ProgRptReqs.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ProgRptReqs(FIX::ProgRptReqs *arg1) {
    delete arg1;
}

swig_class SwigClassTradingSessionID;

SWIGINTERN VALUE
_wrap_new_TradingSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionID";
  FIX::TradingSessionID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradingSessionID *)new FIX::TradingSessionID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradingSessionID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradingSessionID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradingSessionID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradingSessionID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionID";
  FIX::TradingSessionID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradingSessionID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradingSessionID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradingSessionID *)new FIX::TradingSessionID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradingSessionID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradingSessionID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingSessionID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradingSessionID.new", 
    "    TradingSessionID.new()\n"
    "    TradingSessionID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingSessionID(FIX::TradingSessionID *arg1) {
    delete arg1;
}

swig_class SwigClassListOrderStatus;

SWIGINTERN VALUE
_wrap_new_ListOrderStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListOrderStatus";
  FIX::ListOrderStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListOrderStatus *)new FIX::ListOrderStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListOrderStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListOrderStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListOrderStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListOrderStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListOrderStatus";
  FIX::ListOrderStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ListOrderStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ListOrderStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ListOrderStatus *)new FIX::ListOrderStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListOrderStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListOrderStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOrderStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListOrderStatus.new", 
    "    ListOrderStatus.new()\n"
    "    ListOrderStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListOrderStatus(FIX::ListOrderStatus *arg1) {
    delete arg1;
}

swig_class SwigClassRegistStatus;

SWIGINTERN VALUE
_wrap_new_RegistStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistStatus";
  FIX::RegistStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistStatus *)new FIX::RegistStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistStatus";
  FIX::RegistStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::RegistStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::RegistStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RegistStatus *)new FIX::RegistStatus((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistStatus.new", 
    "    RegistStatus.new()\n"
    "    RegistStatus.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistStatus(FIX::RegistStatus *arg1) {
    delete arg1;
}

swig_class SwigClassPosAmt;

SWIGINTERN VALUE
_wrap_new_PosAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosAmt";
  FIX::PosAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosAmt *)new FIX::PosAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosAmt";
  FIX::PosAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::PosAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::PosAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::PosAmt *)new FIX::PosAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosAmt.new", 
    "    PosAmt.new()\n"
    "    PosAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosAmt(FIX::PosAmt *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingPriceDeterminationMethod;

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceDeterminationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceDeterminationMethod";
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingPriceDeterminationMethod *)new FIX::UnderlyingPriceDeterminationMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingPriceDeterminationMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingPriceDeterminationMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceDeterminationMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceDeterminationMethod";
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingPriceDeterminationMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingPriceDeterminationMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingPriceDeterminationMethod *)new FIX::UnderlyingPriceDeterminationMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingPriceDeterminationMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingPriceDeterminationMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPriceDeterminationMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingPriceDeterminationMethod.new", 
    "    UnderlyingPriceDeterminationMethod.new()\n"
    "    UnderlyingPriceDeterminationMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPriceDeterminationMethod(FIX::UnderlyingPriceDeterminationMethod *arg1) {
    delete arg1;
}

swig_class SwigClassNoUnderlyingStips;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingStips__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingStips";
  FIX::NoUnderlyingStips *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUnderlyingStips *)new FIX::NoUnderlyingStips();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUnderlyingStips_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUnderlyingStips_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUnderlyingStips);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUnderlyingStips__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingStips";
  FIX::NoUnderlyingStips *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUnderlyingStips", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUnderlyingStips", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUnderlyingStips *)new FIX::NoUnderlyingStips((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUnderlyingStips(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUnderlyingStips__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingStips__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUnderlyingStips.new", 
    "    NoUnderlyingStips.new()\n"
    "    NoUnderlyingStips.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingStips(FIX::NoUnderlyingStips *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesPreCloseTime;

SWIGINTERN VALUE
_wrap_new_TradSesPreCloseTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesPreCloseTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TradSesPreCloseTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesPreCloseTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesPreCloseTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesPreCloseTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesPreCloseTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesPreCloseTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesPreCloseTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesPreCloseTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesPreCloseTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesPreCloseTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TradSesPreCloseTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesPreCloseTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesPreCloseTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesPreCloseTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TradSesPreCloseTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesPreCloseTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TradSesPreCloseTime.new", 
    "    TradSesPreCloseTime.new()\n"
    "    TradSesPreCloseTime.new(bool showMilliseconds)\n"
    "    TradSesPreCloseTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TradSesPreCloseTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesPreCloseTime(FIX::TradSesPreCloseTime *arg1) {
    delete arg1;
}

swig_class SwigClassMassCancelRequestType;

SWIGINTERN VALUE
_wrap_new_MassCancelRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRequestType";
  FIX::MassCancelRequestType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassCancelRequestType *)new FIX::MassCancelRequestType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassCancelRequestType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassCancelRequestType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassCancelRequestType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassCancelRequestType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRequestType";
  FIX::MassCancelRequestType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MassCancelRequestType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MassCancelRequestType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MassCancelRequestType *)new FIX::MassCancelRequestType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassCancelRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassCancelRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassCancelRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassCancelRequestType.new", 
    "    MassCancelRequestType.new()\n"
    "    MassCancelRequestType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassCancelRequestType(FIX::MassCancelRequestType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltIDSource";
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityAltIDSource *)new FIX::UnderlyingLegSecurityAltIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityAltIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityAltIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltIDSource";
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityAltIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityAltIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityAltIDSource *)new FIX::UnderlyingLegSecurityAltIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityAltIDSource.new", 
    "    UnderlyingLegSecurityAltIDSource.new()\n"
    "    UnderlyingLegSecurityAltIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityAltIDSource(FIX::UnderlyingLegSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPartyID;

SWIGINTERN VALUE
_wrap_new_SettlPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyID";
  FIX::SettlPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPartyID *)new FIX::SettlPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyID";
  FIX::SettlPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlPartyID *)new FIX::SettlPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPartyID.new", 
    "    SettlPartyID.new()\n"
    "    SettlPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartyID(FIX::SettlPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassNoAffectedOrders;

SWIGINTERN VALUE
_wrap_new_NoAffectedOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoAffectedOrders";
  FIX::NoAffectedOrders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoAffectedOrders *)new FIX::NoAffectedOrders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoAffectedOrders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoAffectedOrders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoAffectedOrders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoAffectedOrders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAffectedOrders";
  FIX::NoAffectedOrders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoAffectedOrders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoAffectedOrders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoAffectedOrders *)new FIX::NoAffectedOrders((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoAffectedOrders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoAffectedOrders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAffectedOrders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoAffectedOrders.new", 
    "    NoAffectedOrders.new()\n"
    "    NoAffectedOrders.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAffectedOrders(FIX::NoAffectedOrders *arg1) {
    delete arg1;
}

swig_class SwigClassCashSettlAgentAcctNum;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentAcctNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctNum";
  FIX::CashSettlAgentAcctNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashSettlAgentAcctNum *)new FIX::CashSettlAgentAcctNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashSettlAgentAcctNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashSettlAgentAcctNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashSettlAgentAcctNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashSettlAgentAcctNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctNum";
  FIX::CashSettlAgentAcctNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashSettlAgentAcctNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashSettlAgentAcctNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashSettlAgentAcctNum *)new FIX::CashSettlAgentAcctNum((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashSettlAgentAcctNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashSettlAgentAcctNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentAcctNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashSettlAgentAcctNum.new", 
    "    CashSettlAgentAcctNum.new()\n"
    "    CashSettlAgentAcctNum.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentAcctNum(FIX::CashSettlAgentAcctNum *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityMonthYear";
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegMaturityMonthYear *)new FIX::UnderlyingLegMaturityMonthYear();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegMaturityMonthYear_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegMaturityMonthYear_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityMonthYear";
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::UnderlyingLegMaturityMonthYear", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::UnderlyingLegMaturityMonthYear", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::UnderlyingLegMaturityMonthYear *)new FIX::UnderlyingLegMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegMaturityMonthYear__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegMaturityMonthYear.new", 
    "    UnderlyingLegMaturityMonthYear.new()\n"
    "    UnderlyingLegMaturityMonthYear.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegMaturityMonthYear(FIX::UnderlyingLegMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class SwigClassNoLotTypeRules;

SWIGINTERN VALUE
_wrap_new_NoLotTypeRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoLotTypeRules";
  FIX::NoLotTypeRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoLotTypeRules *)new FIX::NoLotTypeRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoLotTypeRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoLotTypeRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoLotTypeRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoLotTypeRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLotTypeRules";
  FIX::NoLotTypeRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoLotTypeRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoLotTypeRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoLotTypeRules *)new FIX::NoLotTypeRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoLotTypeRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoLotTypeRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLotTypeRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoLotTypeRules.new", 
    "    NoLotTypeRules.new()\n"
    "    NoLotTypeRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLotTypeRules(FIX::NoLotTypeRules *arg1) {
    delete arg1;
}

swig_class SwigClassNoDates;

SWIGINTERN VALUE
_wrap_new_NoDates__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDates";
  FIX::NoDates *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDates *)new FIX::NoDates();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDates_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDates_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDates);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDates__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDates";
  FIX::NoDates *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDates", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDates", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDates *)new FIX::NoDates((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDates(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDates__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDates__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDates.new", 
    "    NoDates.new()\n"
    "    NoDates.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDates(FIX::NoDates *arg1) {
    delete arg1;
}

swig_class SwigClassCxlRejResponseTo;

SWIGINTERN VALUE
_wrap_new_CxlRejResponseTo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CxlRejResponseTo";
  FIX::CxlRejResponseTo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CxlRejResponseTo *)new FIX::CxlRejResponseTo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CxlRejResponseTo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CxlRejResponseTo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CxlRejResponseTo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CxlRejResponseTo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlRejResponseTo";
  FIX::CxlRejResponseTo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::CxlRejResponseTo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::CxlRejResponseTo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::CxlRejResponseTo *)new FIX::CxlRejResponseTo((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CxlRejResponseTo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CxlRejResponseTo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlRejResponseTo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CxlRejResponseTo.new", 
    "    CxlRejResponseTo.new()\n"
    "    CxlRejResponseTo.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlRejResponseTo(FIX::CxlRejResponseTo *arg1) {
    delete arg1;
}

swig_class SwigClassEffectiveTime;

SWIGINTERN VALUE
_wrap_new_EffectiveTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  FIX::EffectiveTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EffectiveTime *)new FIX::EffectiveTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_EffectiveTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  FIX::EffectiveTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::EffectiveTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::EffectiveTime *)new FIX::EffectiveTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_EffectiveTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  FIX::EffectiveTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::EffectiveTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::EffectiveTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::EffectiveTime *)new FIX::EffectiveTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EffectiveTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EffectiveTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EffectiveTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EffectiveTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  FIX::EffectiveTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::EffectiveTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::EffectiveTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::EffectiveTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::EffectiveTime *)new FIX::EffectiveTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EffectiveTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EffectiveTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EffectiveTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EffectiveTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EffectiveTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "EffectiveTime.new", 
    "    EffectiveTime.new()\n"
    "    EffectiveTime.new(bool showMilliseconds)\n"
    "    EffectiveTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    EffectiveTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EffectiveTime(FIX::EffectiveTime *arg1) {
    delete arg1;
}

swig_class SwigClassGrossTradeAmt;

SWIGINTERN VALUE
_wrap_new_GrossTradeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::GrossTradeAmt";
  FIX::GrossTradeAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::GrossTradeAmt *)new FIX::GrossTradeAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_GrossTradeAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_GrossTradeAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__GrossTradeAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_GrossTradeAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GrossTradeAmt";
  FIX::GrossTradeAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::GrossTradeAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::GrossTradeAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::GrossTradeAmt *)new FIX::GrossTradeAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GrossTradeAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_GrossTradeAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GrossTradeAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GrossTradeAmt.new", 
    "    GrossTradeAmt.new()\n"
    "    GrossTradeAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_GrossTradeAmt(FIX::GrossTradeAmt *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityListDesc;

SWIGINTERN VALUE
_wrap_new_SecurityListDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityListDesc";
  FIX::SecurityListDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityListDesc *)new FIX::SecurityListDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityListDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityListDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityListDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityListDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListDesc";
  FIX::SecurityListDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityListDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityListDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityListDesc *)new FIX::SecurityListDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityListDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityListDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityListDesc.new", 
    "    SecurityListDesc.new()\n"
    "    SecurityListDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListDesc(FIX::SecurityListDesc *arg1) {
    delete arg1;
}

swig_class SwigClassNotAffectedOrderID;

SWIGINTERN VALUE
_wrap_new_NotAffectedOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NotAffectedOrderID";
  FIX::NotAffectedOrderID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NotAffectedOrderID *)new FIX::NotAffectedOrderID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NotAffectedOrderID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NotAffectedOrderID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NotAffectedOrderID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NotAffectedOrderID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotAffectedOrderID";
  FIX::NotAffectedOrderID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NotAffectedOrderID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NotAffectedOrderID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NotAffectedOrderID *)new FIX::NotAffectedOrderID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NotAffectedOrderID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NotAffectedOrderID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotAffectedOrderID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NotAffectedOrderID.new", 
    "    NotAffectedOrderID.new()\n"
    "    NotAffectedOrderID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NotAffectedOrderID(FIX::NotAffectedOrderID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeStrikeValue;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeValue";
  FIX::DerivativeStrikeValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeStrikeValue *)new FIX::DerivativeStrikeValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeStrikeValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeStrikeValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeStrikeValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeValue";
  FIX::DerivativeStrikeValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::DerivativeStrikeValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::DerivativeStrikeValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::DerivativeStrikeValue *)new FIX::DerivativeStrikeValue((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeStrikeValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeStrikeValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikeValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeStrikeValue.new", 
    "    DerivativeStrikeValue.new()\n"
    "    DerivativeStrikeValue.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikeValue(FIX::DerivativeStrikeValue *arg1) {
    delete arg1;
}

swig_class SwigClassNoPosAmt;

SWIGINTERN VALUE
_wrap_new_NoPosAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoPosAmt";
  FIX::NoPosAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoPosAmt *)new FIX::NoPosAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoPosAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoPosAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoPosAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoPosAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPosAmt";
  FIX::NoPosAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoPosAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoPosAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPosAmt *)new FIX::NoPosAmt((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPosAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPosAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPosAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoPosAmt.new", 
    "    NoPosAmt.new()\n"
    "    NoPosAmt.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPosAmt(FIX::NoPosAmt *arg1) {
    delete arg1;
}

swig_class SwigClassLegCreditRating;

SWIGINTERN VALUE
_wrap_new_LegCreditRating__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCreditRating";
  FIX::LegCreditRating *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCreditRating *)new FIX::LegCreditRating();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCreditRating_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCreditRating_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCreditRating);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCreditRating__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCreditRating";
  FIX::LegCreditRating *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegCreditRating", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegCreditRating", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegCreditRating *)new FIX::LegCreditRating((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCreditRating(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCreditRating__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCreditRating__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCreditRating.new", 
    "    LegCreditRating.new()\n"
    "    LegCreditRating.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCreditRating(FIX::LegCreditRating *arg1) {
    delete arg1;
}

swig_class SwigClassBidForwardPoints2;

SWIGINTERN VALUE
_wrap_new_BidForwardPoints2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints2";
  FIX::BidForwardPoints2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidForwardPoints2 *)new FIX::BidForwardPoints2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidForwardPoints2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidForwardPoints2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidForwardPoints2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidForwardPoints2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints2";
  FIX::BidForwardPoints2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::BidForwardPoints2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::BidForwardPoints2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::BidForwardPoints2 *)new FIX::BidForwardPoints2((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidForwardPoints2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidForwardPoints2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidForwardPoints2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidForwardPoints2.new", 
    "    BidForwardPoints2.new()\n"
    "    BidForwardPoints2.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidForwardPoints2(FIX::BidForwardPoints2 *arg1) {
    delete arg1;
}

swig_class SwigClassSettlDate;

SWIGINTERN VALUE
_wrap_new_SettlDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlDate";
  FIX::SettlDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlDate *)new FIX::SettlDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDate";
  FIX::SettlDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::SettlDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::SettlDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::SettlDate *)new FIX::SettlDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlDate.new", 
    "    SettlDate.new()\n"
    "    SettlDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDate(FIX::SettlDate *arg1) {
    delete arg1;
}

swig_class SwigClassClientID;

SWIGINTERN VALUE
_wrap_new_ClientID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClientID";
  FIX::ClientID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClientID *)new FIX::ClientID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClientID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClientID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClientID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClientID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClientID";
  FIX::ClientID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClientID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClientID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClientID *)new FIX::ClientID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClientID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClientID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClientID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClientID.new", 
    "    ClientID.new()\n"
    "    ClientID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClientID(FIX::ClientID *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteCancelType;

SWIGINTERN VALUE
_wrap_new_QuoteCancelType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteCancelType";
  FIX::QuoteCancelType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteCancelType *)new FIX::QuoteCancelType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteCancelType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteCancelType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteCancelType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteCancelType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteCancelType";
  FIX::QuoteCancelType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteCancelType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteCancelType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteCancelType *)new FIX::QuoteCancelType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteCancelType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteCancelType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteCancelType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteCancelType.new", 
    "    QuoteCancelType.new()\n"
    "    QuoteCancelType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteCancelType(FIX::QuoteCancelType *arg1) {
    delete arg1;
}

swig_class SwigClassStipulationType;

SWIGINTERN VALUE
_wrap_new_StipulationType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StipulationType";
  FIX::StipulationType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StipulationType *)new FIX::StipulationType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StipulationType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StipulationType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StipulationType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StipulationType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StipulationType";
  FIX::StipulationType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StipulationType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StipulationType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StipulationType *)new FIX::StipulationType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StipulationType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StipulationType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StipulationType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StipulationType.new", 
    "    StipulationType.new()\n"
    "    StipulationType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StipulationType(FIX::StipulationType *arg1) {
    delete arg1;
}

swig_class SwigClassOutMainCntryUIndex;

SWIGINTERN VALUE
_wrap_new_OutMainCntryUIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OutMainCntryUIndex";
  FIX::OutMainCntryUIndex *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OutMainCntryUIndex *)new FIX::OutMainCntryUIndex();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OutMainCntryUIndex_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OutMainCntryUIndex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OutMainCntryUIndex);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OutMainCntryUIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OutMainCntryUIndex";
  FIX::OutMainCntryUIndex *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::OutMainCntryUIndex", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::OutMainCntryUIndex", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::OutMainCntryUIndex *)new FIX::OutMainCntryUIndex((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OutMainCntryUIndex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OutMainCntryUIndex__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutMainCntryUIndex__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OutMainCntryUIndex.new", 
    "    OutMainCntryUIndex.new()\n"
    "    OutMainCntryUIndex.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OutMainCntryUIndex(FIX::OutMainCntryUIndex *arg1) {
    delete arg1;
}

swig_class SwigClassLegSettlmntTyp;

SWIGINTERN VALUE
_wrap_new_LegSettlmntTyp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSettlmntTyp";
  FIX::LegSettlmntTyp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSettlmntTyp *)new FIX::LegSettlmntTyp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSettlmntTyp_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSettlmntTyp_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSettlmntTyp);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSettlmntTyp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlmntTyp";
  FIX::LegSettlmntTyp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LegSettlmntTyp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LegSettlmntTyp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LegSettlmntTyp *)new FIX::LegSettlmntTyp((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSettlmntTyp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSettlmntTyp__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlmntTyp__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSettlmntTyp.new", 
    "    LegSettlmntTyp.new()\n"
    "    LegSettlmntTyp.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlmntTyp(FIX::LegSettlmntTyp *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeNTPositionLimit;

SWIGINTERN VALUE
_wrap_new_DerivativeNTPositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeNTPositionLimit";
  FIX::DerivativeNTPositionLimit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeNTPositionLimit *)new FIX::DerivativeNTPositionLimit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeNTPositionLimit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeNTPositionLimit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeNTPositionLimit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeNTPositionLimit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeNTPositionLimit";
  FIX::DerivativeNTPositionLimit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeNTPositionLimit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeNTPositionLimit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeNTPositionLimit *)new FIX::DerivativeNTPositionLimit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeNTPositionLimit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeNTPositionLimit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeNTPositionLimit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeNTPositionLimit.new", 
    "    DerivativeNTPositionLimit.new()\n"
    "    DerivativeNTPositionLimit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeNTPositionLimit(FIX::DerivativeNTPositionLimit *arg1) {
    delete arg1;
}

swig_class SwigClassPriceQuoteMethod;

SWIGINTERN VALUE
_wrap_new_PriceQuoteMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceQuoteMethod";
  FIX::PriceQuoteMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceQuoteMethod *)new FIX::PriceQuoteMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceQuoteMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceQuoteMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceQuoteMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceQuoteMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceQuoteMethod";
  FIX::PriceQuoteMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PriceQuoteMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PriceQuoteMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PriceQuoteMethod *)new FIX::PriceQuoteMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceQuoteMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceQuoteMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceQuoteMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceQuoteMethod.new", 
    "    PriceQuoteMethod.new()\n"
    "    PriceQuoteMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceQuoteMethod(FIX::PriceQuoteMethod *arg1) {
    delete arg1;
}

swig_class SwigClassLowLimitPrice;

SWIGINTERN VALUE
_wrap_new_LowLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LowLimitPrice";
  FIX::LowLimitPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LowLimitPrice *)new FIX::LowLimitPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LowLimitPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LowLimitPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LowLimitPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LowLimitPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LowLimitPrice";
  FIX::LowLimitPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LowLimitPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LowLimitPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LowLimitPrice *)new FIX::LowLimitPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LowLimitPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LowLimitPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LowLimitPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LowLimitPrice.new", 
    "    LowLimitPrice.new()\n"
    "    LowLimitPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LowLimitPrice(FIX::LowLimitPrice *arg1) {
    delete arg1;
}

swig_class SwigClassLegUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_LegUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasure";
  FIX::LegUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegUnitOfMeasure *)new FIX::LegUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasure";
  FIX::LegUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegUnitOfMeasure *)new FIX::LegUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegUnitOfMeasure.new", 
    "    LegUnitOfMeasure.new()\n"
    "    LegUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegUnitOfMeasure(FIX::LegUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassSessionRejectReason;

SWIGINTERN VALUE
_wrap_new_SessionRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SessionRejectReason";
  FIX::SessionRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SessionRejectReason *)new FIX::SessionRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SessionRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SessionRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SessionRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SessionRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionRejectReason";
  FIX::SessionRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SessionRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SessionRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SessionRejectReason *)new FIX::SessionRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SessionRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SessionRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SessionRejectReason.new", 
    "    SessionRejectReason.new()\n"
    "    SessionRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionRejectReason(FIX::SessionRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassDeliveryType;

SWIGINTERN VALUE
_wrap_new_DeliveryType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeliveryType";
  FIX::DeliveryType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeliveryType *)new FIX::DeliveryType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeliveryType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeliveryType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeliveryType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeliveryType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryType";
  FIX::DeliveryType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DeliveryType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DeliveryType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DeliveryType *)new FIX::DeliveryType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeliveryType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeliveryType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliveryType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeliveryType.new", 
    "    DeliveryType.new()\n"
    "    DeliveryType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliveryType(FIX::DeliveryType *arg1) {
    delete arg1;
}

swig_class SwigClassAllocPrice;

SWIGINTERN VALUE
_wrap_new_AllocPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocPrice";
  FIX::AllocPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocPrice *)new FIX::AllocPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocPrice";
  FIX::AllocPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::AllocPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::AllocPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::AllocPrice *)new FIX::AllocPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocPrice.new", 
    "    AllocPrice.new()\n"
    "    AllocPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocPrice(FIX::AllocPrice *arg1) {
    delete arg1;
}

swig_class SwigClassNoBidComponents;

SWIGINTERN VALUE
_wrap_new_NoBidComponents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoBidComponents";
  FIX::NoBidComponents *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoBidComponents *)new FIX::NoBidComponents();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoBidComponents_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoBidComponents_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoBidComponents);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoBidComponents__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoBidComponents";
  FIX::NoBidComponents *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoBidComponents", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoBidComponents", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoBidComponents *)new FIX::NoBidComponents((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoBidComponents(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoBidComponents__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoBidComponents__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoBidComponents.new", 
    "    NoBidComponents.new()\n"
    "    NoBidComponents.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoBidComponents(FIX::NoBidComponents *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteQualifier;

SWIGINTERN VALUE
_wrap_new_QuoteQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteQualifier";
  FIX::QuoteQualifier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteQualifier *)new FIX::QuoteQualifier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteQualifier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteQualifier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteQualifier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteQualifier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteQualifier";
  FIX::QuoteQualifier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::QuoteQualifier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::QuoteQualifier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::QuoteQualifier *)new FIX::QuoteQualifier((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteQualifier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteQualifier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteQualifier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteQualifier.new", 
    "    QuoteQualifier.new()\n"
    "    QuoteQualifier.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteQualifier(FIX::QuoteQualifier *arg1) {
    delete arg1;
}

swig_class SwigClassScope;

SWIGINTERN VALUE
_wrap_new_Scope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Scope";
  FIX::Scope *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Scope *)new FIX::Scope();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Scope_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Scope_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Scope);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Scope__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Scope";
  FIX::Scope *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::Scope", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::Scope", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::Scope *)new FIX::Scope((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Scope(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Scope__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Scope__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Scope.new", 
    "    Scope.new()\n"
    "    Scope.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Scope(FIX::Scope *arg1) {
    delete arg1;
}

swig_class SwigClassNoSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityAltID";
  FIX::NoSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSecurityAltID *)new FIX::NoSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityAltID";
  FIX::NoSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSecurityAltID *)new FIX::NoSecurityAltID((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSecurityAltID.new", 
    "    NoSecurityAltID.new()\n"
    "    NoSecurityAltID.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSecurityAltID(FIX::NoSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassRootPartySubID;

SWIGINTERN VALUE
_wrap_new_RootPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubID";
  FIX::RootPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RootPartySubID *)new FIX::RootPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RootPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RootPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RootPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RootPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubID";
  FIX::RootPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RootPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RootPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RootPartySubID *)new FIX::RootPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RootPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RootPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RootPartySubID.new", 
    "    RootPartySubID.new()\n"
    "    RootPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartySubID(FIX::RootPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassDeliverToLocationID;

SWIGINTERN VALUE
_wrap_new_DeliverToLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeliverToLocationID";
  FIX::DeliverToLocationID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeliverToLocationID *)new FIX::DeliverToLocationID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeliverToLocationID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeliverToLocationID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeliverToLocationID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeliverToLocationID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToLocationID";
  FIX::DeliverToLocationID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DeliverToLocationID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DeliverToLocationID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DeliverToLocationID *)new FIX::DeliverToLocationID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeliverToLocationID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeliverToLocationID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliverToLocationID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeliverToLocationID.new", 
    "    DeliverToLocationID.new()\n"
    "    DeliverToLocationID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliverToLocationID(FIX::DeliverToLocationID *arg1) {
    delete arg1;
}

swig_class SwigClassDeleteReason;

SWIGINTERN VALUE
_wrap_new_DeleteReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeleteReason";
  FIX::DeleteReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeleteReason *)new FIX::DeleteReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeleteReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeleteReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeleteReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeleteReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeleteReason";
  FIX::DeleteReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DeleteReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DeleteReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DeleteReason *)new FIX::DeleteReason((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeleteReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeleteReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeleteReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeleteReason.new", 
    "    DeleteReason.new()\n"
    "    DeleteReason.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeleteReason(FIX::DeleteReason *arg1) {
    delete arg1;
}

swig_class SwigClassBidSpotRate;

SWIGINTERN VALUE
_wrap_new_BidSpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidSpotRate";
  FIX::BidSpotRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidSpotRate *)new FIX::BidSpotRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidSpotRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidSpotRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidSpotRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidSpotRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSpotRate";
  FIX::BidSpotRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::BidSpotRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::BidSpotRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::BidSpotRate *)new FIX::BidSpotRate((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidSpotRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidSpotRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidSpotRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidSpotRate.new", 
    "    BidSpotRate.new()\n"
    "    BidSpotRate.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidSpotRate(FIX::BidSpotRate *arg1) {
    delete arg1;
}

swig_class SwigClassNested4PartyID;

SWIGINTERN VALUE
_wrap_new_Nested4PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyID";
  FIX::Nested4PartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested4PartyID *)new FIX::Nested4PartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested4PartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested4PartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested4PartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested4PartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyID";
  FIX::Nested4PartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Nested4PartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Nested4PartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Nested4PartyID *)new FIX::Nested4PartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested4PartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested4PartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested4PartyID.new", 
    "    Nested4PartyID.new()\n"
    "    Nested4PartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartyID(FIX::Nested4PartyID *arg1) {
    delete arg1;
}

swig_class SwigClassInViewOfCommon;

SWIGINTERN VALUE
_wrap_new_InViewOfCommon__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InViewOfCommon";
  FIX::InViewOfCommon *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InViewOfCommon *)new FIX::InViewOfCommon();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InViewOfCommon_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InViewOfCommon_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InViewOfCommon);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InViewOfCommon__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InViewOfCommon";
  FIX::InViewOfCommon *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::InViewOfCommon", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::InViewOfCommon", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::InViewOfCommon *)new FIX::InViewOfCommon((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InViewOfCommon(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InViewOfCommon__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InViewOfCommon__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InViewOfCommon.new", 
    "    InViewOfCommon.new()\n"
    "    InViewOfCommon.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InViewOfCommon(FIX::InViewOfCommon *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSettlPrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPrice";
  FIX::UnderlyingSettlPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSettlPrice *)new FIX::UnderlyingSettlPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSettlPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSettlPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSettlPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPrice";
  FIX::UnderlyingSettlPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingSettlPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingSettlPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingSettlPrice *)new FIX::UnderlyingSettlPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSettlPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSettlPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSettlPrice.new", 
    "    UnderlyingSettlPrice.new()\n"
    "    UnderlyingSettlPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlPrice(FIX::UnderlyingSettlPrice *arg1) {
    delete arg1;
}

swig_class SwigClassRegistRejReasonText;

SWIGINTERN VALUE
_wrap_new_RegistRejReasonText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonText";
  FIX::RegistRejReasonText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistRejReasonText *)new FIX::RegistRejReasonText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistRejReasonText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistRejReasonText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistRejReasonText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistRejReasonText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonText";
  FIX::RegistRejReasonText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistRejReasonText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistRejReasonText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistRejReasonText *)new FIX::RegistRejReasonText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistRejReasonText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistRejReasonText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistRejReasonText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistRejReasonText.new", 
    "    RegistRejReasonText.new()\n"
    "    RegistRejReasonText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistRejReasonText(FIX::RegistRejReasonText *arg1) {
    delete arg1;
}

swig_class SwigClassNoSides;

SWIGINTERN VALUE
_wrap_new_NoSides__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSides";
  FIX::NoSides *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSides *)new FIX::NoSides();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSides_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSides_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSides);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSides__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSides";
  FIX::NoSides *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSides", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSides", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSides *)new FIX::NoSides((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSides(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSides__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSides__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSides.new", 
    "    NoSides.new()\n"
    "    NoSides.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSides(FIX::NoSides *arg1) {
    delete arg1;
}

swig_class SwigClassLegAllocAccount;

SWIGINTERN VALUE
_wrap_new_LegAllocAccount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAccount";
  FIX::LegAllocAccount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegAllocAccount *)new FIX::LegAllocAccount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegAllocAccount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegAllocAccount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegAllocAccount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegAllocAccount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAccount";
  FIX::LegAllocAccount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegAllocAccount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegAllocAccount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegAllocAccount *)new FIX::LegAllocAccount((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegAllocAccount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegAllocAccount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocAccount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegAllocAccount.new", 
    "    LegAllocAccount.new()\n"
    "    LegAllocAccount.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocAccount(FIX::LegAllocAccount *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_LegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityDesc";
  FIX::LegSecurityDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityDesc *)new FIX::LegSecurityDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityDesc";
  FIX::LegSecurityDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecurityDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecurityDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecurityDesc *)new FIX::LegSecurityDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityDesc.new", 
    "    LegSecurityDesc.new()\n"
    "    LegSecurityDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityDesc(FIX::LegSecurityDesc *arg1) {
    delete arg1;
}

swig_class SwigClassClOrdLinkID;

SWIGINTERN VALUE
_wrap_new_ClOrdLinkID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClOrdLinkID";
  FIX::ClOrdLinkID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClOrdLinkID *)new FIX::ClOrdLinkID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClOrdLinkID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClOrdLinkID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClOrdLinkID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClOrdLinkID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClOrdLinkID";
  FIX::ClOrdLinkID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClOrdLinkID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClOrdLinkID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClOrdLinkID *)new FIX::ClOrdLinkID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClOrdLinkID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClOrdLinkID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClOrdLinkID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClOrdLinkID.new", 
    "    ClOrdLinkID.new()\n"
    "    ClOrdLinkID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClOrdLinkID(FIX::ClOrdLinkID *arg1) {
    delete arg1;
}

swig_class SwigClassOrigSendingTime;

SWIGINTERN VALUE
_wrap_new_OrigSendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  FIX::OrigSendingTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OrigSendingTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  FIX::OrigSendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::OrigSendingTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OrigSendingTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  FIX::OrigSendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OrigSendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OrigSendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigSendingTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigSendingTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigSendingTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigSendingTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  FIX::OrigSendingTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OrigSendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OrigSendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::OrigSendingTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigSendingTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigSendingTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigSendingTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_OrigSendingTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrigSendingTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "OrigSendingTime.new", 
    "    OrigSendingTime.new()\n"
    "    OrigSendingTime.new(bool showMilliseconds)\n"
    "    OrigSendingTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    OrigSendingTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigSendingTime(FIX::OrigSendingTime *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedLegIssuerLen;

SWIGINTERN VALUE
_wrap_new_EncodedLegIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuerLen";
  FIX::EncodedLegIssuerLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedLegIssuerLen *)new FIX::EncodedLegIssuerLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedLegIssuerLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedLegIssuerLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedLegIssuerLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedLegIssuerLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuerLen";
  FIX::EncodedLegIssuerLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedLegIssuerLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedLegIssuerLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedLegIssuerLen *)new FIX::EncodedLegIssuerLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedLegIssuerLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedLegIssuerLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegIssuerLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedLegIssuerLen.new", 
    "    EncodedLegIssuerLen.new()\n"
    "    EncodedLegIssuerLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegIssuerLen(FIX::EncodedLegIssuerLen *arg1) {
    delete arg1;
}

swig_class SwigClassOrderID;

SWIGINTERN VALUE
_wrap_new_OrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderID";
  FIX::OrderID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderID *)new FIX::OrderID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderID";
  FIX::OrderID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrderID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrderID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrderID *)new FIX::OrderID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderID.new", 
    "    OrderID.new()\n"
    "    OrderID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderID(FIX::OrderID *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityType;

SWIGINTERN VALUE
_wrap_new_SecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityType";
  FIX::SecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityType *)new FIX::SecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityType";
  FIX::SecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityType *)new FIX::SecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityType.new", 
    "    SecurityType.new()\n"
    "    SecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityType(FIX::SecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassRoundingDirection;

SWIGINTERN VALUE
_wrap_new_RoundingDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RoundingDirection";
  FIX::RoundingDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RoundingDirection *)new FIX::RoundingDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoundingDirection_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoundingDirection_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RoundingDirection);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoundingDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundingDirection";
  FIX::RoundingDirection *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::RoundingDirection", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::RoundingDirection", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RoundingDirection *)new FIX::RoundingDirection((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RoundingDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RoundingDirection__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoundingDirection__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RoundingDirection.new", 
    "    RoundingDirection.new()\n"
    "    RoundingDirection.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RoundingDirection(FIX::RoundingDirection *arg1) {
    delete arg1;
}

swig_class SwigClassFillExecID;

SWIGINTERN VALUE
_wrap_new_FillExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FillExecID";
  FIX::FillExecID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FillExecID *)new FIX::FillExecID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FillExecID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FillExecID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FillExecID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FillExecID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillExecID";
  FIX::FillExecID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::FillExecID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::FillExecID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::FillExecID *)new FIX::FillExecID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FillExecID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FillExecID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillExecID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FillExecID.new", 
    "    FillExecID.new()\n"
    "    FillExecID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FillExecID(FIX::FillExecID *arg1) {
    delete arg1;
}

swig_class SwigClassNoEvents;

SWIGINTERN VALUE
_wrap_new_NoEvents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoEvents";
  FIX::NoEvents *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoEvents *)new FIX::NoEvents();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoEvents_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoEvents_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoEvents);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoEvents__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoEvents";
  FIX::NoEvents *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoEvents", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoEvents", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoEvents *)new FIX::NoEvents((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoEvents(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoEvents__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoEvents__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoEvents.new", 
    "    NoEvents.new()\n"
    "    NoEvents.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoEvents(FIX::NoEvents *arg1) {
    delete arg1;
}

swig_class SwigClassRoundLot;

SWIGINTERN VALUE
_wrap_new_RoundLot__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RoundLot";
  FIX::RoundLot *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RoundLot *)new FIX::RoundLot();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoundLot_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoundLot_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RoundLot);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoundLot__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundLot";
  FIX::RoundLot *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::RoundLot", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::RoundLot", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::RoundLot *)new FIX::RoundLot((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RoundLot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RoundLot__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoundLot__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RoundLot.new", 
    "    RoundLot.new()\n"
    "    RoundLot.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RoundLot(FIX::RoundLot *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntrySize;

SWIGINTERN VALUE
_wrap_new_MDEntrySize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySize";
  FIX::MDEntrySize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntrySize *)new FIX::MDEntrySize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntrySize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntrySize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntrySize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntrySize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySize";
  FIX::MDEntrySize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MDEntrySize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MDEntrySize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MDEntrySize *)new FIX::MDEntrySize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntrySize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntrySize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntrySize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntrySize.new", 
    "    MDEntrySize.new()\n"
    "    MDEntrySize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntrySize(FIX::MDEntrySize *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedIssuerLen;

SWIGINTERN VALUE
_wrap_new_EncodedIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuerLen";
  FIX::EncodedIssuerLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedIssuerLen *)new FIX::EncodedIssuerLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedIssuerLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedIssuerLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedIssuerLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedIssuerLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuerLen";
  FIX::EncodedIssuerLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedIssuerLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedIssuerLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedIssuerLen *)new FIX::EncodedIssuerLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedIssuerLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedIssuerLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedIssuerLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedIssuerLen.new", 
    "    EncodedIssuerLen.new()\n"
    "    EncodedIssuerLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedIssuerLen(FIX::EncodedIssuerLen *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativePriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasureQty";
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativePriceUnitOfMeasureQty *)new FIX::DerivativePriceUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativePriceUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativePriceUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasureQty";
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DerivativePriceUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DerivativePriceUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DerivativePriceUnitOfMeasureQty *)new FIX::DerivativePriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativePriceUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativePriceUnitOfMeasureQty.new", 
    "    DerivativePriceUnitOfMeasureQty.new()\n"
    "    DerivativePriceUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePriceUnitOfMeasureQty(FIX::DerivativePriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassTimeUnit;

SWIGINTERN VALUE
_wrap_new_TimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TimeUnit";
  FIX::TimeUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TimeUnit *)new FIX::TimeUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TimeUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TimeUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TimeUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TimeUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeUnit";
  FIX::TimeUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TimeUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TimeUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TimeUnit *)new FIX::TimeUnit((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TimeUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TimeUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TimeUnit.new", 
    "    TimeUnit.new()\n"
    "    TimeUnit.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeUnit(FIX::TimeUnit *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoOrders;

SWIGINTERN VALUE
_wrap_new_TotNoOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoOrders";
  FIX::TotNoOrders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoOrders *)new FIX::TotNoOrders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoOrders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoOrders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoOrders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoOrders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoOrders";
  FIX::TotNoOrders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoOrders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoOrders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoOrders *)new FIX::TotNoOrders((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoOrders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoOrders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoOrders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoOrders.new", 
    "    TotNoOrders.new()\n"
    "    TotNoOrders.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoOrders(FIX::TotNoOrders *arg1) {
    delete arg1;
}

swig_class SwigClassLegSwapType;

SWIGINTERN VALUE
_wrap_new_LegSwapType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSwapType";
  FIX::LegSwapType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSwapType *)new FIX::LegSwapType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSwapType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSwapType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSwapType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSwapType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSwapType";
  FIX::LegSwapType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegSwapType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegSwapType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegSwapType *)new FIX::LegSwapType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSwapType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSwapType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSwapType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSwapType.new", 
    "    LegSwapType.new()\n"
    "    LegSwapType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSwapType(FIX::LegSwapType *arg1) {
    delete arg1;
}

swig_class SwigClassIOITransType;

SWIGINTERN VALUE
_wrap_new_IOITransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOITransType";
  FIX::IOITransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOITransType *)new FIX::IOITransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOITransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOITransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOITransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOITransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOITransType";
  FIX::IOITransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::IOITransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::IOITransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::IOITransType *)new FIX::IOITransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOITransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOITransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOITransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOITransType.new", 
    "    IOITransType.new()\n"
    "    IOITransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOITransType(FIX::IOITransType *arg1) {
    delete arg1;
}

swig_class SwigClassRawDataLength;

SWIGINTERN VALUE
_wrap_new_RawDataLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RawDataLength";
  FIX::RawDataLength *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RawDataLength *)new FIX::RawDataLength();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RawDataLength_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RawDataLength_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RawDataLength);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RawDataLength__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RawDataLength";
  FIX::RawDataLength *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::RawDataLength", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::RawDataLength", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::RawDataLength *)new FIX::RawDataLength((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RawDataLength(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RawDataLength__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawDataLength__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RawDataLength.new", 
    "    RawDataLength.new()\n"
    "    RawDataLength.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RawDataLength(FIX::RawDataLength *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityType";
  FIX::UnderlyingSecurityType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityType *)new FIX::UnderlyingSecurityType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityType";
  FIX::UnderlyingSecurityType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecurityType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecurityType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecurityType *)new FIX::UnderlyingSecurityType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityType.new", 
    "    UnderlyingSecurityType.new()\n"
    "    UnderlyingSecurityType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityType(FIX::UnderlyingSecurityType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltID";
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityAltID *)new FIX::UnderlyingLegSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltID";
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityAltID *)new FIX::UnderlyingLegSecurityAltID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityAltID.new", 
    "    UnderlyingLegSecurityAltID.new()\n"
    "    UnderlyingLegSecurityAltID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityAltID(FIX::UnderlyingLegSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityReportID;

SWIGINTERN VALUE
_wrap_new_SecurityReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityReportID";
  FIX::SecurityReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityReportID *)new FIX::SecurityReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityReportID";
  FIX::SecurityReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityReportID *)new FIX::SecurityReportID((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityReportID.new", 
    "    SecurityReportID.new()\n"
    "    SecurityReportID.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityReportID(FIX::SecurityReportID *arg1) {
    delete arg1;
}

swig_class SwigClassTotNumReports;

SWIGINTERN VALUE
_wrap_new_TotNumReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNumReports";
  FIX::TotNumReports *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNumReports *)new FIX::TotNumReports();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNumReports_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNumReports_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNumReports);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNumReports__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumReports";
  FIX::TotNumReports *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNumReports", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNumReports", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNumReports *)new FIX::TotNumReports((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNumReports(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNumReports__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNumReports__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNumReports.new", 
    "    TotNumReports.new()\n"
    "    TotNumReports.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNumReports(FIX::TotNumReports *arg1) {
    delete arg1;
}

swig_class SwigClassTotalNumPosReports;

SWIGINTERN VALUE
_wrap_new_TotalNumPosReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalNumPosReports";
  FIX::TotalNumPosReports *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalNumPosReports *)new FIX::TotalNumPosReports();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalNumPosReports_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalNumPosReports_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalNumPosReports);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalNumPosReports__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumPosReports";
  FIX::TotalNumPosReports *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotalNumPosReports", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotalNumPosReports", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotalNumPosReports *)new FIX::TotalNumPosReports((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalNumPosReports(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalNumPosReports__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNumPosReports__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalNumPosReports.new", 
    "    TotalNumPosReports.new()\n"
    "    TotalNumPosReports.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNumPosReports(FIX::TotalNumPosReports *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityReqID;

SWIGINTERN VALUE
_wrap_new_SecurityReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityReqID";
  FIX::SecurityReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityReqID *)new FIX::SecurityReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityReqID";
  FIX::SecurityReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityReqID *)new FIX::SecurityReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityReqID.new", 
    "    SecurityReqID.new()\n"
    "    SecurityReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityReqID(FIX::SecurityReqID *arg1) {
    delete arg1;
}

swig_class SwigClassPosReqResult;

SWIGINTERN VALUE
_wrap_new_PosReqResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosReqResult";
  FIX::PosReqResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosReqResult *)new FIX::PosReqResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosReqResult_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosReqResult_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosReqResult);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosReqResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqResult";
  FIX::PosReqResult *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosReqResult", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosReqResult", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosReqResult *)new FIX::PosReqResult((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosReqResult(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosReqResult__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqResult__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosReqResult.new", 
    "    PosReqResult.new()\n"
    "    PosReqResult.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqResult(FIX::PosReqResult *arg1) {
    delete arg1;
}

swig_class SwigClassLegOfferForwardPoints;

SWIGINTERN VALUE
_wrap_new_LegOfferForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegOfferForwardPoints";
  FIX::LegOfferForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegOfferForwardPoints *)new FIX::LegOfferForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegOfferForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegOfferForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegOfferForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegOfferForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOfferForwardPoints";
  FIX::LegOfferForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::LegOfferForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::LegOfferForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::LegOfferForwardPoints *)new FIX::LegOfferForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegOfferForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegOfferForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOfferForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegOfferForwardPoints.new", 
    "    LegOfferForwardPoints.new()\n"
    "    LegOfferForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOfferForwardPoints(FIX::LegOfferForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassAllowableOneSidednessCurr;

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessCurr";
  FIX::AllowableOneSidednessCurr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllowableOneSidednessCurr *)new FIX::AllowableOneSidednessCurr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllowableOneSidednessCurr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllowableOneSidednessCurr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllowableOneSidednessCurr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessCurr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessCurr";
  FIX::AllowableOneSidednessCurr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::AllowableOneSidednessCurr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::AllowableOneSidednessCurr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::AllowableOneSidednessCurr *)new FIX::AllowableOneSidednessCurr((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllowableOneSidednessCurr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllowableOneSidednessCurr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllowableOneSidednessCurr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllowableOneSidednessCurr.new", 
    "    AllowableOneSidednessCurr.new()\n"
    "    AllowableOneSidednessCurr.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllowableOneSidednessCurr(FIX::AllowableOneSidednessCurr *arg1) {
    delete arg1;
}

swig_class SwigClassAffectedOrderID;

SWIGINTERN VALUE
_wrap_new_AffectedOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AffectedOrderID";
  FIX::AffectedOrderID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AffectedOrderID *)new FIX::AffectedOrderID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AffectedOrderID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AffectedOrderID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AffectedOrderID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AffectedOrderID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffectedOrderID";
  FIX::AffectedOrderID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AffectedOrderID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AffectedOrderID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AffectedOrderID *)new FIX::AffectedOrderID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AffectedOrderID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AffectedOrderID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AffectedOrderID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AffectedOrderID.new", 
    "    AffectedOrderID.new()\n"
    "    AffectedOrderID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AffectedOrderID(FIX::AffectedOrderID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_UnderlyingCountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCountryOfIssue";
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCountryOfIssue *)new FIX::UnderlyingCountryOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCountryOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCountryOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCountryOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCountryOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCountryOfIssue";
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__COUNTRY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::COUNTRY const &","FIX::UnderlyingCountryOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::COUNTRY const &","FIX::UnderlyingCountryOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  result = (FIX::UnderlyingCountryOfIssue *)new FIX::UnderlyingCountryOfIssue((FIX::COUNTRY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCountryOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCountryOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCountryOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCountryOfIssue.new", 
    "    UnderlyingCountryOfIssue.new()\n"
    "    UnderlyingCountryOfIssue.new(FIX::COUNTRY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCountryOfIssue(FIX::UnderlyingCountryOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingRepurchaseRate;

SWIGINTERN VALUE
_wrap_new_UnderlyingRepurchaseRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseRate";
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingRepurchaseRate *)new FIX::UnderlyingRepurchaseRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingRepurchaseRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingRepurchaseRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingRepurchaseRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingRepurchaseRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseRate";
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingRepurchaseRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingRepurchaseRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingRepurchaseRate *)new FIX::UnderlyingRepurchaseRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingRepurchaseRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingRepurchaseRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepurchaseRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingRepurchaseRate.new", 
    "    UnderlyingRepurchaseRate.new()\n"
    "    UnderlyingRepurchaseRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRepurchaseRate(FIX::UnderlyingRepurchaseRate *arg1) {
    delete arg1;
}

swig_class SwigClassLastMsgSeqNumProcessed;

SWIGINTERN VALUE
_wrap_new_LastMsgSeqNumProcessed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastMsgSeqNumProcessed";
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastMsgSeqNumProcessed *)new FIX::LastMsgSeqNumProcessed();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastMsgSeqNumProcessed_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastMsgSeqNumProcessed_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastMsgSeqNumProcessed);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastMsgSeqNumProcessed__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastMsgSeqNumProcessed";
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::LastMsgSeqNumProcessed", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::LastMsgSeqNumProcessed", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::LastMsgSeqNumProcessed *)new FIX::LastMsgSeqNumProcessed((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastMsgSeqNumProcessed(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastMsgSeqNumProcessed__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastMsgSeqNumProcessed__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastMsgSeqNumProcessed.new", 
    "    LastMsgSeqNumProcessed.new()\n"
    "    LastMsgSeqNumProcessed.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastMsgSeqNumProcessed(FIX::LastMsgSeqNumProcessed *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCFICode;

SWIGINTERN VALUE
_wrap_new_UnderlyingCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCFICode";
  FIX::UnderlyingCFICode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCFICode *)new FIX::UnderlyingCFICode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCFICode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCFICode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCFICode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCFICode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCFICode";
  FIX::UnderlyingCFICode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingCFICode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingCFICode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingCFICode *)new FIX::UnderlyingCFICode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCFICode.new", 
    "    UnderlyingCFICode.new()\n"
    "    UnderlyingCFICode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCFICode(FIX::UnderlyingCFICode *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeOptAttribute;

SWIGINTERN VALUE
_wrap_new_DerivativeOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptAttribute";
  FIX::DerivativeOptAttribute *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeOptAttribute *)new FIX::DerivativeOptAttribute();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeOptAttribute_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeOptAttribute_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeOptAttribute);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeOptAttribute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptAttribute";
  FIX::DerivativeOptAttribute *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DerivativeOptAttribute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DerivativeOptAttribute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DerivativeOptAttribute *)new FIX::DerivativeOptAttribute((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeOptAttribute(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeOptAttribute__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeOptAttribute__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeOptAttribute.new", 
    "    DerivativeOptAttribute.new()\n"
    "    DerivativeOptAttribute.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeOptAttribute(FIX::DerivativeOptAttribute *arg1) {
    delete arg1;
}

swig_class SwigClassPegSecurityID;

SWIGINTERN VALUE
_wrap_new_PegSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityID";
  FIX::PegSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegSecurityID *)new FIX::PegSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityID";
  FIX::PegSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PegSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PegSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PegSecurityID *)new FIX::PegSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegSecurityID.new", 
    "    PegSecurityID.new()\n"
    "    PegSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSecurityID(FIX::PegSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassHostCrossID;

SWIGINTERN VALUE
_wrap_new_HostCrossID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HostCrossID";
  FIX::HostCrossID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HostCrossID *)new FIX::HostCrossID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HostCrossID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HostCrossID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HostCrossID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HostCrossID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HostCrossID";
  FIX::HostCrossID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::HostCrossID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::HostCrossID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::HostCrossID *)new FIX::HostCrossID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HostCrossID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HostCrossID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HostCrossID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HostCrossID.new", 
    "    HostCrossID.new()\n"
    "    HostCrossID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HostCrossID(FIX::HostCrossID *arg1) {
    delete arg1;
}

swig_class SwigClassExecInstValue;

SWIGINTERN VALUE
_wrap_new_ExecInstValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecInstValue";
  FIX::ExecInstValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecInstValue *)new FIX::ExecInstValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecInstValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecInstValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecInstValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecInstValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecInstValue";
  FIX::ExecInstValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExecInstValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExecInstValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExecInstValue *)new FIX::ExecInstValue((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecInstValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecInstValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecInstValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecInstValue.new", 
    "    ExecInstValue.new()\n"
    "    ExecInstValue.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecInstValue(FIX::ExecInstValue *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeOptPayAmount;

SWIGINTERN VALUE
_wrap_new_DerivativeOptPayAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptPayAmount";
  FIX::DerivativeOptPayAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeOptPayAmount *)new FIX::DerivativeOptPayAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeOptPayAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeOptPayAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeOptPayAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeOptPayAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptPayAmount";
  FIX::DerivativeOptPayAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::DerivativeOptPayAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::DerivativeOptPayAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::DerivativeOptPayAmount *)new FIX::DerivativeOptPayAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeOptPayAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeOptPayAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeOptPayAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeOptPayAmount.new", 
    "    DerivativeOptPayAmount.new()\n"
    "    DerivativeOptPayAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeOptPayAmount(FIX::DerivativeOptPayAmount *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCouponRate;

SWIGINTERN VALUE
_wrap_new_UnderlyingCouponRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponRate";
  FIX::UnderlyingCouponRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCouponRate *)new FIX::UnderlyingCouponRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCouponRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCouponRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCouponRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCouponRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponRate";
  FIX::UnderlyingCouponRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingCouponRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingCouponRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingCouponRate *)new FIX::UnderlyingCouponRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCouponRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCouponRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCouponRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCouponRate.new", 
    "    UnderlyingCouponRate.new()\n"
    "    UnderlyingCouponRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCouponRate(FIX::UnderlyingCouponRate *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstMode;

SWIGINTERN VALUE
_wrap_new_SettlInstMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMode";
  FIX::SettlInstMode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstMode *)new FIX::SettlInstMode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstMode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstMode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstMode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstMode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMode";
  FIX::SettlInstMode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlInstMode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlInstMode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlInstMode *)new FIX::SettlInstMode((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstMode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstMode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstMode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstMode.new", 
    "    SettlInstMode.new()\n"
    "    SettlInstMode.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstMode(FIX::SettlInstMode *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_SecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltIDSource";
  FIX::SecurityAltIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityAltIDSource *)new FIX::SecurityAltIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityAltIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityAltIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityAltIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltIDSource";
  FIX::SecurityAltIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityAltIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityAltIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityAltIDSource *)new FIX::SecurityAltIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityAltIDSource.new", 
    "    SecurityAltIDSource.new()\n"
    "    SecurityAltIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityAltIDSource(FIX::SecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassPreviouslyReported;

SWIGINTERN VALUE
_wrap_new_PreviouslyReported__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PreviouslyReported";
  FIX::PreviouslyReported *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PreviouslyReported *)new FIX::PreviouslyReported();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PreviouslyReported_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PreviouslyReported_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PreviouslyReported);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PreviouslyReported__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreviouslyReported";
  FIX::PreviouslyReported *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PreviouslyReported", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PreviouslyReported", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PreviouslyReported *)new FIX::PreviouslyReported((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PreviouslyReported(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PreviouslyReported__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PreviouslyReported__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PreviouslyReported.new", 
    "    PreviouslyReported.new()\n"
    "    PreviouslyReported.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PreviouslyReported(FIX::PreviouslyReported *arg1) {
    delete arg1;
}

swig_class SwigClassRptSys;

SWIGINTERN VALUE
_wrap_new_RptSys__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RptSys";
  FIX::RptSys *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RptSys *)new FIX::RptSys();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RptSys_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RptSys_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RptSys);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RptSys__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RptSys";
  FIX::RptSys *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RptSys", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RptSys", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RptSys *)new FIX::RptSys((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RptSys(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RptSys__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RptSys__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RptSys.new", 
    "    RptSys.new()\n"
    "    RptSys.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RptSys(FIX::RptSys *arg1) {
    delete arg1;
}

swig_class SwigClassNoNested2PartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNested2PartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartySubIDs";
  FIX::NoNested2PartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNested2PartySubIDs *)new FIX::NoNested2PartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNested2PartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNested2PartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNested2PartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNested2PartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartySubIDs";
  FIX::NoNested2PartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNested2PartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNested2PartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNested2PartySubIDs *)new FIX::NoNested2PartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNested2PartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNested2PartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested2PartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNested2PartySubIDs.new", 
    "    NoNested2PartySubIDs.new()\n"
    "    NoNested2PartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested2PartySubIDs(FIX::NoNested2PartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassRefAllocID;

SWIGINTERN VALUE
_wrap_new_RefAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefAllocID";
  FIX::RefAllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefAllocID *)new FIX::RefAllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefAllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefAllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefAllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefAllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefAllocID";
  FIX::RefAllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefAllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefAllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefAllocID *)new FIX::RefAllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefAllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefAllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefAllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefAllocID.new", 
    "    RefAllocID.new()\n"
    "    RefAllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefAllocID(FIX::RefAllocID *arg1) {
    delete arg1;
}

swig_class SwigClassDefOfferSize;

SWIGINTERN VALUE
_wrap_new_DefOfferSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DefOfferSize";
  FIX::DefOfferSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DefOfferSize *)new FIX::DefOfferSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DefOfferSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DefOfferSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DefOfferSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DefOfferSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefOfferSize";
  FIX::DefOfferSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DefOfferSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DefOfferSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DefOfferSize *)new FIX::DefOfferSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefOfferSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DefOfferSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefOfferSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DefOfferSize.new", 
    "    DefOfferSize.new()\n"
    "    DefOfferSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DefOfferSize(FIX::DefOfferSize *arg1) {
    delete arg1;
}

swig_class SwigClassProductComplex;

SWIGINTERN VALUE
_wrap_new_ProductComplex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ProductComplex";
  FIX::ProductComplex *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ProductComplex *)new FIX::ProductComplex();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ProductComplex_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ProductComplex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ProductComplex);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ProductComplex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProductComplex";
  FIX::ProductComplex *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ProductComplex", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ProductComplex", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ProductComplex *)new FIX::ProductComplex((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ProductComplex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ProductComplex__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProductComplex__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ProductComplex.new", 
    "    ProductComplex.new()\n"
    "    ProductComplex.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ProductComplex(FIX::ProductComplex *arg1) {
    delete arg1;
}

swig_class SwigClassCustOrderHandlingInst;

SWIGINTERN VALUE
_wrap_new_CustOrderHandlingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CustOrderHandlingInst";
  FIX::CustOrderHandlingInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CustOrderHandlingInst *)new FIX::CustOrderHandlingInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CustOrderHandlingInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CustOrderHandlingInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CustOrderHandlingInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustOrderHandlingInst";
  FIX::CustOrderHandlingInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLESTRINGVALUE const &","FIX::CustOrderHandlingInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLESTRINGVALUE const &","FIX::CustOrderHandlingInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  result = (FIX::CustOrderHandlingInst *)new FIX::CustOrderHandlingInst((FIX::MULTIPLESTRINGVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CustOrderHandlingInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CustOrderHandlingInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustOrderHandlingInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CustOrderHandlingInst.new", 
    "    CustOrderHandlingInst.new()\n"
    "    CustOrderHandlingInst.new(FIX::MULTIPLESTRINGVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CustOrderHandlingInst(FIX::CustOrderHandlingInst *arg1) {
    delete arg1;
}

swig_class SwigClassMDPriceLevel;

SWIGINTERN VALUE
_wrap_new_MDPriceLevel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDPriceLevel";
  FIX::MDPriceLevel *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDPriceLevel *)new FIX::MDPriceLevel();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDPriceLevel_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDPriceLevel_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDPriceLevel);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDPriceLevel__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDPriceLevel";
  FIX::MDPriceLevel *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDPriceLevel", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDPriceLevel", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDPriceLevel *)new FIX::MDPriceLevel((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDPriceLevel(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDPriceLevel__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDPriceLevel__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDPriceLevel.new", 
    "    MDPriceLevel.new()\n"
    "    MDPriceLevel.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDPriceLevel(FIX::MDPriceLevel *arg1) {
    delete arg1;
}

swig_class SwigClassLegOptionRatio;

SWIGINTERN VALUE
_wrap_new_LegOptionRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegOptionRatio";
  FIX::LegOptionRatio *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegOptionRatio *)new FIX::LegOptionRatio();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegOptionRatio_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegOptionRatio_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegOptionRatio);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegOptionRatio__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOptionRatio";
  FIX::LegOptionRatio *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::LegOptionRatio", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::LegOptionRatio", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::LegOptionRatio *)new FIX::LegOptionRatio((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegOptionRatio(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegOptionRatio__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOptionRatio__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegOptionRatio.new", 
    "    LegOptionRatio.new()\n"
    "    LegOptionRatio.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOptionRatio(FIX::LegOptionRatio *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityStatus;

SWIGINTERN VALUE
_wrap_new_SecurityStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatus";
  FIX::SecurityStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityStatus *)new FIX::SecurityStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatus";
  FIX::SecurityStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityStatus *)new FIX::SecurityStatus((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityStatus.new", 
    "    SecurityStatus.new()\n"
    "    SecurityStatus.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityStatus(FIX::SecurityStatus *arg1) {
    delete arg1;
}

swig_class SwigClassLegRefID;

SWIGINTERN VALUE
_wrap_new_LegRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegRefID";
  FIX::LegRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegRefID *)new FIX::LegRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRefID";
  FIX::LegRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegRefID *)new FIX::LegRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegRefID.new", 
    "    LegRefID.new()\n"
    "    LegRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRefID(FIX::LegRefID *arg1) {
    delete arg1;
}

swig_class SwigClassDividendYield;

SWIGINTERN VALUE
_wrap_new_DividendYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DividendYield";
  FIX::DividendYield *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DividendYield *)new FIX::DividendYield();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DividendYield_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DividendYield_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DividendYield);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DividendYield__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DividendYield";
  FIX::DividendYield *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::DividendYield", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::DividendYield", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::DividendYield *)new FIX::DividendYield((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DividendYield(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DividendYield__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DividendYield__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DividendYield.new", 
    "    DividendYield.new()\n"
    "    DividendYield.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DividendYield(FIX::DividendYield *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubIDType";
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrumentPartySubIDType *)new FIX::DerivativeInstrumentPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrumentPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrumentPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubIDType";
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeInstrumentPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeInstrumentPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeInstrumentPartySubIDType *)new FIX::DerivativeInstrumentPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrumentPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrumentPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrumentPartySubIDType.new", 
    "    DerivativeInstrumentPartySubIDType.new()\n"
    "    DerivativeInstrumentPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartySubIDType(FIX::DerivativeInstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassEndStrikePxRange;

SWIGINTERN VALUE
_wrap_new_EndStrikePxRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndStrikePxRange";
  FIX::EndStrikePxRange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndStrikePxRange *)new FIX::EndStrikePxRange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndStrikePxRange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndStrikePxRange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndStrikePxRange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndStrikePxRange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndStrikePxRange";
  FIX::EndStrikePxRange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::EndStrikePxRange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::EndStrikePxRange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::EndStrikePxRange *)new FIX::EndStrikePxRange((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndStrikePxRange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndStrikePxRange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndStrikePxRange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndStrikePxRange.new", 
    "    EndStrikePxRange.new()\n"
    "    EndStrikePxRange.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndStrikePxRange(FIX::EndStrikePxRange *arg1) {
    delete arg1;
}

swig_class SwigClassDisplayQty;

SWIGINTERN VALUE
_wrap_new_DisplayQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DisplayQty";
  FIX::DisplayQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DisplayQty *)new FIX::DisplayQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DisplayQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DisplayQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DisplayQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DisplayQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayQty";
  FIX::DisplayQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::DisplayQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::DisplayQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::DisplayQty *)new FIX::DisplayQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DisplayQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DisplayQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DisplayQty.new", 
    "    DisplayQty.new()\n"
    "    DisplayQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayQty(FIX::DisplayQty *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecuritySubType;

SWIGINTERN VALUE
_wrap_new_LegSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecuritySubType";
  FIX::LegSecuritySubType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecuritySubType *)new FIX::LegSecuritySubType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecuritySubType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecuritySubType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecuritySubType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecuritySubType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecuritySubType";
  FIX::LegSecuritySubType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecuritySubType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecuritySubType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecuritySubType *)new FIX::LegSecuritySubType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecuritySubType.new", 
    "    LegSecuritySubType.new()\n"
    "    LegSecuritySubType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecuritySubType(FIX::LegSecuritySubType *arg1) {
    delete arg1;
}

swig_class SwigClassProcessCode;

SWIGINTERN VALUE
_wrap_new_ProcessCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ProcessCode";
  FIX::ProcessCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ProcessCode *)new FIX::ProcessCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ProcessCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ProcessCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ProcessCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ProcessCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProcessCode";
  FIX::ProcessCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ProcessCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ProcessCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ProcessCode *)new FIX::ProcessCode((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ProcessCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ProcessCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProcessCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ProcessCode.new", 
    "    ProcessCode.new()\n"
    "    ProcessCode.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ProcessCode(FIX::ProcessCode *arg1) {
    delete arg1;
}

swig_class SwigClassExecInst;

SWIGINTERN VALUE
_wrap_new_ExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecInst";
  FIX::ExecInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecInst *)new FIX::ExecInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecInst";
  FIX::ExecInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::ExecInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::ExecInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::ExecInst *)new FIX::ExecInst((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecInst.new", 
    "    ExecInst.new()\n"
    "    ExecInst.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecInst(FIX::ExecInst *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesEndTime;

SWIGINTERN VALUE
_wrap_new_TradSesEndTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  FIX::TradSesEndTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesEndTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  FIX::TradSesEndTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TradSesEndTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TradSesEndTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  FIX::TradSesEndTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesEndTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesEndTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesEndTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesEndTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesEndTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesEndTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  FIX::TradSesEndTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TradSesEndTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TradSesEndTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TradSesEndTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesEndTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesEndTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesEndTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TradSesEndTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesEndTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TradSesEndTime.new", 
    "    TradSesEndTime.new()\n"
    "    TradSesEndTime.new(bool showMilliseconds)\n"
    "    TradSesEndTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TradSesEndTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesEndTime(FIX::TradSesEndTime *arg1) {
    delete arg1;
}

swig_class SwigClassOrigTime;

SWIGINTERN VALUE
_wrap_new_OrigTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  FIX::OrigTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigTime *)new FIX::OrigTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OrigTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  FIX::OrigTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::OrigTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::OrigTime *)new FIX::OrigTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OrigTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  FIX::OrigTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OrigTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OrigTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::OrigTime *)new FIX::OrigTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  FIX::OrigTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OrigTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OrigTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::OrigTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::OrigTime *)new FIX::OrigTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_OrigTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrigTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "OrigTime.new", 
    "    OrigTime.new()\n"
    "    OrigTime.new(bool showMilliseconds)\n"
    "    OrigTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    OrigTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTime(FIX::OrigTime *arg1) {
    delete arg1;
}

swig_class SwigClassExecValuationPoint;

SWIGINTERN VALUE
_wrap_new_ExecValuationPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  FIX::ExecValuationPoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ExecValuationPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  FIX::ExecValuationPoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ExecValuationPoint", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ExecValuationPoint__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  FIX::ExecValuationPoint *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ExecValuationPoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ExecValuationPoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecValuationPoint_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecValuationPoint_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecValuationPoint);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecValuationPoint__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  FIX::ExecValuationPoint *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ExecValuationPoint", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ExecValuationPoint", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ExecValuationPoint", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecValuationPoint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecValuationPoint__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecValuationPoint__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ExecValuationPoint__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExecValuationPoint__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ExecValuationPoint.new", 
    "    ExecValuationPoint.new()\n"
    "    ExecValuationPoint.new(bool showMilliseconds)\n"
    "    ExecValuationPoint.new(FIX::UTCTIMESTAMP const &value)\n"
    "    ExecValuationPoint.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecValuationPoint(FIX::ExecValuationPoint *arg1) {
    delete arg1;
}

swig_class SwigClassExecType;

SWIGINTERN VALUE
_wrap_new_ExecType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecType";
  FIX::ExecType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecType *)new FIX::ExecType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecType";
  FIX::ExecType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExecType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExecType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExecType *)new FIX::ExecType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecType.new", 
    "    ExecType.new()\n"
    "    ExecType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecType(FIX::ExecType *arg1) {
    delete arg1;
}

swig_class SwigClassNested4PartyRole;

SWIGINTERN VALUE
_wrap_new_Nested4PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyRole";
  FIX::Nested4PartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested4PartyRole *)new FIX::Nested4PartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested4PartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested4PartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested4PartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested4PartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyRole";
  FIX::Nested4PartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Nested4PartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Nested4PartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Nested4PartyRole *)new FIX::Nested4PartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested4PartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested4PartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested4PartyRole.new", 
    "    Nested4PartyRole.new()\n"
    "    Nested4PartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartyRole(FIX::Nested4PartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassMultilegModel;

SWIGINTERN VALUE
_wrap_new_MultilegModel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MultilegModel";
  FIX::MultilegModel *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MultilegModel *)new FIX::MultilegModel();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MultilegModel_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MultilegModel_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MultilegModel);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MultilegModel__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultilegModel";
  FIX::MultilegModel *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MultilegModel", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MultilegModel", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MultilegModel *)new FIX::MultilegModel((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MultilegModel(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MultilegModel__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultilegModel__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MultilegModel.new", 
    "    MultilegModel.new()\n"
    "    MultilegModel.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MultilegModel(FIX::MultilegModel *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityGroup;

SWIGINTERN VALUE
_wrap_new_SecurityGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityGroup";
  FIX::SecurityGroup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityGroup *)new FIX::SecurityGroup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityGroup_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityGroup_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityGroup);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityGroup";
  FIX::SecurityGroup *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityGroup", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityGroup", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityGroup *)new FIX::SecurityGroup((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityGroup__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityGroup__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityGroup.new", 
    "    SecurityGroup.new()\n"
    "    SecurityGroup.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityGroup(FIX::SecurityGroup *arg1) {
    delete arg1;
}

swig_class SwigClassEventType;

SWIGINTERN VALUE
_wrap_new_EventType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EventType";
  FIX::EventType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EventType *)new FIX::EventType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EventType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EventType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EventType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EventType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventType";
  FIX::EventType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::EventType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::EventType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::EventType *)new FIX::EventType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EventType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EventType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EventType.new", 
    "    EventType.new()\n"
    "    EventType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EventType(FIX::EventType *arg1) {
    delete arg1;
}

swig_class SwigClassTradeAllocIndicator;

SWIGINTERN VALUE
_wrap_new_TradeAllocIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeAllocIndicator";
  FIX::TradeAllocIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeAllocIndicator *)new FIX::TradeAllocIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeAllocIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeAllocIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeAllocIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeAllocIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeAllocIndicator";
  FIX::TradeAllocIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeAllocIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeAllocIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeAllocIndicator *)new FIX::TradeAllocIndicator((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeAllocIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeAllocIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeAllocIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeAllocIndicator.new", 
    "    TradeAllocIndicator.new()\n"
    "    TradeAllocIndicator.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeAllocIndicator(FIX::TradeAllocIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassYieldCalcDate;

SWIGINTERN VALUE
_wrap_new_YieldCalcDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::YieldCalcDate";
  FIX::YieldCalcDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::YieldCalcDate *)new FIX::YieldCalcDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_YieldCalcDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_YieldCalcDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__YieldCalcDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_YieldCalcDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldCalcDate";
  FIX::YieldCalcDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::YieldCalcDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::YieldCalcDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::YieldCalcDate *)new FIX::YieldCalcDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_YieldCalcDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_YieldCalcDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldCalcDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "YieldCalcDate.new", 
    "    YieldCalcDate.new()\n"
    "    YieldCalcDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldCalcDate(FIX::YieldCalcDate *arg1) {
    delete arg1;
}

swig_class SwigClassValueOfFutures;

SWIGINTERN VALUE
_wrap_new_ValueOfFutures__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ValueOfFutures";
  FIX::ValueOfFutures *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ValueOfFutures *)new FIX::ValueOfFutures();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ValueOfFutures_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ValueOfFutures_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ValueOfFutures);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ValueOfFutures__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValueOfFutures";
  FIX::ValueOfFutures *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::ValueOfFutures", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::ValueOfFutures", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::ValueOfFutures *)new FIX::ValueOfFutures((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ValueOfFutures(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ValueOfFutures__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ValueOfFutures__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ValueOfFutures.new", 
    "    ValueOfFutures.new()\n"
    "    ValueOfFutures.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ValueOfFutures(FIX::ValueOfFutures *arg1) {
    delete arg1;
}

swig_class SwigClassLegSide;

SWIGINTERN VALUE
_wrap_new_LegSide__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSide";
  FIX::LegSide *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSide *)new FIX::LegSide();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSide_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSide_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSide);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSide__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSide";
  FIX::LegSide *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LegSide", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LegSide", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LegSide *)new FIX::LegSide((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSide(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSide__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSide__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSide.new", 
    "    LegSide.new()\n"
    "    LegSide.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSide(FIX::LegSide *arg1) {
    delete arg1;
}

swig_class SwigClassUserStatus;

SWIGINTERN VALUE
_wrap_new_UserStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UserStatus";
  FIX::UserStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UserStatus *)new FIX::UserStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UserStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UserStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UserStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UserStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserStatus";
  FIX::UserStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UserStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UserStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UserStatus *)new FIX::UserStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UserStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UserStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UserStatus.new", 
    "    UserStatus.new()\n"
    "    UserStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UserStatus(FIX::UserStatus *arg1) {
    delete arg1;
}

swig_class SwigClassSideValue1;

SWIGINTERN VALUE
_wrap_new_SideValue1__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideValue1";
  FIX::SideValue1 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideValue1 *)new FIX::SideValue1();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideValue1_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideValue1_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideValue1);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideValue1__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValue1";
  FIX::SideValue1 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::SideValue1", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::SideValue1", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::SideValue1 *)new FIX::SideValue1((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideValue1(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideValue1__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideValue1__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideValue1.new", 
    "    SideValue1.new()\n"
    "    SideValue1.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideValue1(FIX::SideValue1 *arg1) {
    delete arg1;
}

swig_class SwigClassCxlQty;

SWIGINTERN VALUE
_wrap_new_CxlQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CxlQty";
  FIX::CxlQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CxlQty *)new FIX::CxlQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CxlQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CxlQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CxlQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CxlQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlQty";
  FIX::CxlQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::CxlQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::CxlQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::CxlQty *)new FIX::CxlQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CxlQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CxlQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CxlQty.new", 
    "    CxlQty.new()\n"
    "    CxlQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlQty(FIX::CxlQty *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityResponseID;

SWIGINTERN VALUE
_wrap_new_SecurityResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseID";
  FIX::SecurityResponseID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityResponseID *)new FIX::SecurityResponseID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityResponseID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityResponseID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityResponseID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityResponseID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseID";
  FIX::SecurityResponseID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityResponseID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityResponseID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityResponseID *)new FIX::SecurityResponseID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityResponseID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityResponseID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityResponseID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityResponseID.new", 
    "    SecurityResponseID.new()\n"
    "    SecurityResponseID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityResponseID(FIX::SecurityResponseID *arg1) {
    delete arg1;
}

swig_class SwigClassInstrRegistry;

SWIGINTERN VALUE
_wrap_new_InstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrRegistry";
  FIX::InstrRegistry *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrRegistry *)new FIX::InstrRegistry();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrRegistry_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrRegistry_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrRegistry);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrRegistry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrRegistry";
  FIX::InstrRegistry *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::InstrRegistry", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::InstrRegistry", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::InstrRegistry *)new FIX::InstrRegistry((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrRegistry(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrRegistry__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrRegistry__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrRegistry.new", 
    "    InstrRegistry.new()\n"
    "    InstrRegistry.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrRegistry(FIX::InstrRegistry *arg1) {
    delete arg1;
}

swig_class SwigClassStreamAsgnRptID;

SWIGINTERN VALUE
_wrap_new_StreamAsgnRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRptID";
  FIX::StreamAsgnRptID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StreamAsgnRptID *)new FIX::StreamAsgnRptID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StreamAsgnRptID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StreamAsgnRptID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StreamAsgnRptID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StreamAsgnRptID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRptID";
  FIX::StreamAsgnRptID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StreamAsgnRptID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StreamAsgnRptID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StreamAsgnRptID *)new FIX::StreamAsgnRptID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamAsgnRptID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StreamAsgnRptID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnRptID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StreamAsgnRptID.new", 
    "    StreamAsgnRptID.new()\n"
    "    StreamAsgnRptID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnRptID(FIX::StreamAsgnRptID *arg1) {
    delete arg1;
}

swig_class SwigClassOrderDelayUnit;

SWIGINTERN VALUE
_wrap_new_OrderDelayUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderDelayUnit";
  FIX::OrderDelayUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderDelayUnit *)new FIX::OrderDelayUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderDelayUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderDelayUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderDelayUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderDelayUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderDelayUnit";
  FIX::OrderDelayUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OrderDelayUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OrderDelayUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OrderDelayUnit *)new FIX::OrderDelayUnit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderDelayUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderDelayUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderDelayUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderDelayUnit.new", 
    "    OrderDelayUnit.new()\n"
    "    OrderDelayUnit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderDelayUnit(FIX::OrderDelayUnit *arg1) {
    delete arg1;
}

swig_class SwigClassLegCurrencyRatio;

SWIGINTERN VALUE
_wrap_new_LegCurrencyRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCurrencyRatio";
  FIX::LegCurrencyRatio *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCurrencyRatio *)new FIX::LegCurrencyRatio();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCurrencyRatio_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCurrencyRatio_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCurrencyRatio);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCurrencyRatio__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCurrencyRatio";
  FIX::LegCurrencyRatio *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::LegCurrencyRatio", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::LegCurrencyRatio", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::LegCurrencyRatio *)new FIX::LegCurrencyRatio((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCurrencyRatio(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCurrencyRatio__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCurrencyRatio__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCurrencyRatio.new", 
    "    LegCurrencyRatio.new()\n"
    "    LegCurrencyRatio.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCurrencyRatio(FIX::LegCurrencyRatio *arg1) {
    delete arg1;
}

swig_class SwigClassEndTickPriceRange;

SWIGINTERN VALUE
_wrap_new_EndTickPriceRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndTickPriceRange";
  FIX::EndTickPriceRange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndTickPriceRange *)new FIX::EndTickPriceRange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndTickPriceRange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndTickPriceRange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndTickPriceRange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndTickPriceRange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndTickPriceRange";
  FIX::EndTickPriceRange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::EndTickPriceRange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::EndTickPriceRange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::EndTickPriceRange *)new FIX::EndTickPriceRange((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndTickPriceRange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndTickPriceRange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndTickPriceRange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndTickPriceRange.new", 
    "    EndTickPriceRange.new()\n"
    "    EndTickPriceRange.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndTickPriceRange(FIX::EndTickPriceRange *arg1) {
    delete arg1;
}

swig_class SwigClassCollReqID;

SWIGINTERN VALUE
_wrap_new_CollReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollReqID";
  FIX::CollReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollReqID *)new FIX::CollReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollReqID";
  FIX::CollReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CollReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CollReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CollReqID *)new FIX::CollReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollReqID.new", 
    "    CollReqID.new()\n"
    "    CollReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollReqID(FIX::CollReqID *arg1) {
    delete arg1;
}

swig_class SwigClassLegPool;

SWIGINTERN VALUE
_wrap_new_LegPool__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPool";
  FIX::LegPool *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPool *)new FIX::LegPool();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPool_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPool_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPool);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPool__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPool";
  FIX::LegPool *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegPool", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegPool", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegPool *)new FIX::LegPool((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPool(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPool__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPool__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPool.new", 
    "    LegPool.new()\n"
    "    LegPool.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPool(FIX::LegPool *arg1) {
    delete arg1;
}

swig_class SwigClassShortQty;

SWIGINTERN VALUE
_wrap_new_ShortQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ShortQty";
  FIX::ShortQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ShortQty *)new FIX::ShortQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ShortQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ShortQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ShortQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ShortQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ShortQty";
  FIX::ShortQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::ShortQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::ShortQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::ShortQty *)new FIX::ShortQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ShortQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ShortQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ShortQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ShortQty.new", 
    "    ShortQty.new()\n"
    "    ShortQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ShortQty(FIX::ShortQty *arg1) {
    delete arg1;
}

swig_class SwigClassSideValue2;

SWIGINTERN VALUE
_wrap_new_SideValue2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideValue2";
  FIX::SideValue2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideValue2 *)new FIX::SideValue2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideValue2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideValue2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideValue2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideValue2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValue2";
  FIX::SideValue2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::SideValue2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::SideValue2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::SideValue2 *)new FIX::SideValue2((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideValue2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideValue2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideValue2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideValue2.new", 
    "    SideValue2.new()\n"
    "    SideValue2.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideValue2(FIX::SideValue2 *arg1) {
    delete arg1;
}

swig_class SwigClassTradedFlatSwitch;

SWIGINTERN VALUE
_wrap_new_TradedFlatSwitch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradedFlatSwitch";
  FIX::TradedFlatSwitch *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradedFlatSwitch *)new FIX::TradedFlatSwitch();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradedFlatSwitch_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradedFlatSwitch_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradedFlatSwitch);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradedFlatSwitch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradedFlatSwitch";
  FIX::TradedFlatSwitch *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::TradedFlatSwitch", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::TradedFlatSwitch", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::TradedFlatSwitch *)new FIX::TradedFlatSwitch((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradedFlatSwitch(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradedFlatSwitch__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradedFlatSwitch__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradedFlatSwitch.new", 
    "    TradedFlatSwitch.new()\n"
    "    TradedFlatSwitch.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradedFlatSwitch(FIX::TradedFlatSwitch *arg1) {
    delete arg1;
}

swig_class SwigClassMassStatusReqID;

SWIGINTERN VALUE
_wrap_new_MassStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqID";
  FIX::MassStatusReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MassStatusReqID *)new FIX::MassStatusReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MassStatusReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MassStatusReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MassStatusReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MassStatusReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqID";
  FIX::MassStatusReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MassStatusReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MassStatusReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MassStatusReqID *)new FIX::MassStatusReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MassStatusReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MassStatusReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassStatusReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MassStatusReqID.new", 
    "    MassStatusReqID.new()\n"
    "    MassStatusReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MassStatusReqID(FIX::MassStatusReqID *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventEndDate;

SWIGINTERN VALUE
_wrap_new_ComplexEventEndDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  FIX::ComplexEventEndDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ComplexEventEndDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  FIX::ComplexEventEndDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ComplexEventEndDate", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ComplexEventEndDate__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  FIX::ComplexEventEndDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventEndDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventEndDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventEndDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventEndDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventEndDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventEndDate__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  FIX::ComplexEventEndDate *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventEndDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventEndDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ComplexEventEndDate", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventEndDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventEndDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventEndDate__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ComplexEventEndDate__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ComplexEventEndDate__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ComplexEventEndDate.new", 
    "    ComplexEventEndDate.new()\n"
    "    ComplexEventEndDate.new(bool showMilliseconds)\n"
    "    ComplexEventEndDate.new(FIX::UTCTIMESTAMP const &value)\n"
    "    ComplexEventEndDate.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventEndDate(FIX::ComplexEventEndDate *arg1) {
    delete arg1;
}

swig_class SwigClassMarketID;

SWIGINTERN VALUE
_wrap_new_MarketID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketID";
  FIX::MarketID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketID *)new FIX::MarketID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketID";
  FIX::MarketID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::MarketID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::MarketID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::MarketID *)new FIX::MarketID((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketID.new", 
    "    MarketID.new()\n"
    "    MarketID.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketID(FIX::MarketID *arg1) {
    delete arg1;
}

swig_class SwigClassOrigTradeDate;

SWIGINTERN VALUE
_wrap_new_OrigTradeDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeDate";
  FIX::OrigTradeDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigTradeDate *)new FIX::OrigTradeDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigTradeDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigTradeDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigTradeDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigTradeDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeDate";
  FIX::OrigTradeDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::OrigTradeDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::OrigTradeDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::OrigTradeDate *)new FIX::OrigTradeDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigTradeDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigTradeDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTradeDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigTradeDate.new", 
    "    OrigTradeDate.new()\n"
    "    OrigTradeDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTradeDate(FIX::OrigTradeDate *arg1) {
    delete arg1;
}

swig_class SwigClassPreTradeAnonymity;

SWIGINTERN VALUE
_wrap_new_PreTradeAnonymity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PreTradeAnonymity";
  FIX::PreTradeAnonymity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PreTradeAnonymity *)new FIX::PreTradeAnonymity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PreTradeAnonymity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PreTradeAnonymity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PreTradeAnonymity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PreTradeAnonymity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreTradeAnonymity";
  FIX::PreTradeAnonymity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PreTradeAnonymity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PreTradeAnonymity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PreTradeAnonymity *)new FIX::PreTradeAnonymity((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PreTradeAnonymity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PreTradeAnonymity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PreTradeAnonymity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PreTradeAnonymity.new", 
    "    PreTradeAnonymity.new()\n"
    "    PreTradeAnonymity.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PreTradeAnonymity(FIX::PreTradeAnonymity *arg1) {
    delete arg1;
}

swig_class SwigClassTrdRptStatus;

SWIGINTERN VALUE
_wrap_new_TrdRptStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdRptStatus";
  FIX::TrdRptStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdRptStatus *)new FIX::TrdRptStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdRptStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdRptStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdRptStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdRptStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRptStatus";
  FIX::TrdRptStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TrdRptStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TrdRptStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TrdRptStatus *)new FIX::TrdRptStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdRptStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdRptStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRptStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdRptStatus.new", 
    "    TrdRptStatus.new()\n"
    "    TrdRptStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRptStatus(FIX::TrdRptStatus *arg1) {
    delete arg1;
}

swig_class SwigClassDistribPercentage;

SWIGINTERN VALUE
_wrap_new_DistribPercentage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DistribPercentage";
  FIX::DistribPercentage *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DistribPercentage *)new FIX::DistribPercentage();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DistribPercentage_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DistribPercentage_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DistribPercentage);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DistribPercentage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DistribPercentage";
  FIX::DistribPercentage *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::DistribPercentage", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::DistribPercentage", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::DistribPercentage *)new FIX::DistribPercentage((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DistribPercentage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DistribPercentage__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DistribPercentage__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DistribPercentage.new", 
    "    DistribPercentage.new()\n"
    "    DistribPercentage.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DistribPercentage(FIX::DistribPercentage *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteStatus;

SWIGINTERN VALUE
_wrap_new_QuoteStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatus";
  FIX::QuoteStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteStatus *)new FIX::QuoteStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatus";
  FIX::QuoteStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteStatus *)new FIX::QuoteStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteStatus.new", 
    "    QuoteStatus.new()\n"
    "    QuoteStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteStatus(FIX::QuoteStatus *arg1) {
    delete arg1;
}

swig_class SwigClassClearingAccount;

SWIGINTERN VALUE
_wrap_new_ClearingAccount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClearingAccount";
  FIX::ClearingAccount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClearingAccount *)new FIX::ClearingAccount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClearingAccount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClearingAccount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClearingAccount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClearingAccount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingAccount";
  FIX::ClearingAccount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClearingAccount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClearingAccount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClearingAccount *)new FIX::ClearingAccount((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClearingAccount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClearingAccount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingAccount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClearingAccount.new", 
    "    ClearingAccount.new()\n"
    "    ClearingAccount.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingAccount(FIX::ClearingAccount *arg1) {
    delete arg1;
}

swig_class SwigClassTrdMatchID;

SWIGINTERN VALUE
_wrap_new_TrdMatchID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdMatchID";
  FIX::TrdMatchID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdMatchID *)new FIX::TrdMatchID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdMatchID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdMatchID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdMatchID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdMatchID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdMatchID";
  FIX::TrdMatchID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TrdMatchID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TrdMatchID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TrdMatchID *)new FIX::TrdMatchID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdMatchID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdMatchID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdMatchID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdMatchID.new", 
    "    TrdMatchID.new()\n"
    "    TrdMatchID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdMatchID(FIX::TrdMatchID *arg1) {
    delete arg1;
}

swig_class SwigClassOrderInputDevice;

SWIGINTERN VALUE
_wrap_new_OrderInputDevice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderInputDevice";
  FIX::OrderInputDevice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderInputDevice *)new FIX::OrderInputDevice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderInputDevice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderInputDevice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderInputDevice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderInputDevice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderInputDevice";
  FIX::OrderInputDevice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrderInputDevice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrderInputDevice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrderInputDevice *)new FIX::OrderInputDevice((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderInputDevice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderInputDevice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderInputDevice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderInputDevice.new", 
    "    OrderInputDevice.new()\n"
    "    OrderInputDevice.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderInputDevice(FIX::OrderInputDevice *arg1) {
    delete arg1;
}

swig_class SwigClassSolicitedFlag;

SWIGINTERN VALUE
_wrap_new_SolicitedFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SolicitedFlag";
  FIX::SolicitedFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SolicitedFlag *)new FIX::SolicitedFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SolicitedFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SolicitedFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SolicitedFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SolicitedFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SolicitedFlag";
  FIX::SolicitedFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::SolicitedFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::SolicitedFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::SolicitedFlag *)new FIX::SolicitedFlag((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SolicitedFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SolicitedFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SolicitedFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SolicitedFlag.new", 
    "    SolicitedFlag.new()\n"
    "    SolicitedFlag.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SolicitedFlag(FIX::SolicitedFlag *arg1) {
    delete arg1;
}

swig_class SwigClassTransactTime;

SWIGINTERN VALUE
_wrap_new_TransactTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  FIX::TransactTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TransactTime *)new FIX::TransactTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TransactTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  FIX::TransactTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TransactTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TransactTime *)new FIX::TransactTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TransactTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  FIX::TransactTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TransactTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TransactTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TransactTime *)new FIX::TransactTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TransactTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TransactTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TransactTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TransactTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  FIX::TransactTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TransactTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TransactTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TransactTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TransactTime *)new FIX::TransactTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TransactTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TransactTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransactTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TransactTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TransactTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TransactTime.new", 
    "    TransactTime.new()\n"
    "    TransactTime.new(bool showMilliseconds)\n"
    "    TransactTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TransactTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TransactTime(FIX::TransactTime *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_UnderlyingFlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFlowScheduleType";
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingFlowScheduleType *)new FIX::UnderlyingFlowScheduleType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingFlowScheduleType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingFlowScheduleType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingFlowScheduleType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingFlowScheduleType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFlowScheduleType";
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingFlowScheduleType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingFlowScheduleType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingFlowScheduleType *)new FIX::UnderlyingFlowScheduleType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingFlowScheduleType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingFlowScheduleType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFlowScheduleType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingFlowScheduleType.new", 
    "    UnderlyingFlowScheduleType.new()\n"
    "    UnderlyingFlowScheduleType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFlowScheduleType(FIX::UnderlyingFlowScheduleType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingStipValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingStipValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipValue";
  FIX::UnderlyingStipValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingStipValue *)new FIX::UnderlyingStipValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingStipValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingStipValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingStipValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingStipValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipValue";
  FIX::UnderlyingStipValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingStipValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingStipValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingStipValue *)new FIX::UnderlyingStipValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingStipValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingStipValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStipValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingStipValue.new", 
    "    UnderlyingStipValue.new()\n"
    "    UnderlyingStipValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStipValue(FIX::UnderlyingStipValue *arg1) {
    delete arg1;
}

swig_class SwigClassNextExpectedMsgSeqNum;

SWIGINTERN VALUE
_wrap_new_NextExpectedMsgSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NextExpectedMsgSeqNum";
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NextExpectedMsgSeqNum *)new FIX::NextExpectedMsgSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NextExpectedMsgSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NextExpectedMsgSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NextExpectedMsgSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NextExpectedMsgSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NextExpectedMsgSeqNum";
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::NextExpectedMsgSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::NextExpectedMsgSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::NextExpectedMsgSeqNum *)new FIX::NextExpectedMsgSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NextExpectedMsgSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NextExpectedMsgSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NextExpectedMsgSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NextExpectedMsgSeqNum.new", 
    "    NextExpectedMsgSeqNum.new()\n"
    "    NextExpectedMsgSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NextExpectedMsgSeqNum(FIX::NextExpectedMsgSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkCurveCurrency;

SWIGINTERN VALUE
_wrap_new_BenchmarkCurveCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveCurrency";
  FIX::BenchmarkCurveCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkCurveCurrency *)new FIX::BenchmarkCurveCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkCurveCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkCurveCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkCurveCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkCurveCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveCurrency";
  FIX::BenchmarkCurveCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::BenchmarkCurveCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::BenchmarkCurveCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::BenchmarkCurveCurrency *)new FIX::BenchmarkCurveCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkCurveCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkCurveCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkCurveCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkCurveCurrency.new", 
    "    BenchmarkCurveCurrency.new()\n"
    "    BenchmarkCurveCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkCurveCurrency(FIX::BenchmarkCurveCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassCFICode;

SWIGINTERN VALUE
_wrap_new_CFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CFICode";
  FIX::CFICode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CFICode *)new FIX::CFICode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CFICode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CFICode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CFICode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CFICode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CFICode";
  FIX::CFICode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CFICode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CFICode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CFICode *)new FIX::CFICode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CFICode.new", 
    "    CFICode.new()\n"
    "    CFICode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CFICode(FIX::CFICode *arg1) {
    delete arg1;
}

swig_class SwigClassFactor;

SWIGINTERN VALUE
_wrap_new_Factor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Factor";
  FIX::Factor *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Factor *)new FIX::Factor();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Factor_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Factor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Factor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Factor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Factor";
  FIX::Factor *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::Factor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::Factor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::Factor *)new FIX::Factor((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Factor(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Factor__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Factor__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Factor.new", 
    "    Factor.new()\n"
    "    Factor.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Factor(FIX::Factor *arg1) {
    delete arg1;
}

swig_class SwigClassLastShares;

SWIGINTERN VALUE
_wrap_new_LastShares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastShares";
  FIX::LastShares *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastShares *)new FIX::LastShares();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastShares_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastShares_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastShares);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastShares__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastShares";
  FIX::LastShares *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LastShares", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LastShares", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LastShares *)new FIX::LastShares((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastShares(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastShares__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastShares__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastShares.new", 
    "    LastShares.new()\n"
    "    LastShares.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastShares(FIX::LastShares *arg1) {
    delete arg1;
}

swig_class SwigClassEventTime;

SWIGINTERN VALUE
_wrap_new_EventTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  FIX::EventTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EventTime *)new FIX::EventTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_EventTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  FIX::EventTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::EventTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::EventTime *)new FIX::EventTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_EventTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  FIX::EventTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::EventTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::EventTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::EventTime *)new FIX::EventTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EventTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EventTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EventTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EventTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  FIX::EventTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::EventTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::EventTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::EventTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::EventTime *)new FIX::EventTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EventTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EventTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EventTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EventTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "EventTime.new", 
    "    EventTime.new()\n"
    "    EventTime.new(bool showMilliseconds)\n"
    "    EventTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    EventTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EventTime(FIX::EventTime *arg1) {
    delete arg1;
}

swig_class SwigClassRootPartySubIDType;

SWIGINTERN VALUE
_wrap_new_RootPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubIDType";
  FIX::RootPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RootPartySubIDType *)new FIX::RootPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RootPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RootPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RootPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RootPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubIDType";
  FIX::RootPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RootPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RootPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RootPartySubIDType *)new FIX::RootPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RootPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RootPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RootPartySubIDType.new", 
    "    RootPartySubIDType.new()\n"
    "    RootPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartySubIDType(FIX::RootPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassShortSaleReason;

SWIGINTERN VALUE
_wrap_new_ShortSaleReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ShortSaleReason";
  FIX::ShortSaleReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ShortSaleReason *)new FIX::ShortSaleReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ShortSaleReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ShortSaleReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ShortSaleReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ShortSaleReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ShortSaleReason";
  FIX::ShortSaleReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ShortSaleReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ShortSaleReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ShortSaleReason *)new FIX::ShortSaleReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ShortSaleReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ShortSaleReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ShortSaleReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ShortSaleReason.new", 
    "    ShortSaleReason.new()\n"
    "    ShortSaleReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ShortSaleReason(FIX::ShortSaleReason *arg1) {
    delete arg1;
}

swig_class SwigClassXmlData;

SWIGINTERN VALUE
_wrap_new_XmlData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::XmlData";
  FIX::XmlData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::XmlData *)new FIX::XmlData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_XmlData_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_XmlData_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__XmlData);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_XmlData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::XmlData";
  FIX::XmlData *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::XmlData", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::XmlData", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::XmlData *)new FIX::XmlData((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_XmlData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_XmlData__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XmlData__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "XmlData.new", 
    "    XmlData.new()\n"
    "    XmlData.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_XmlData(FIX::XmlData *arg1) {
    delete arg1;
}

swig_class SwigClassNoTargetPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoTargetPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTargetPartyIDs";
  FIX::NoTargetPartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTargetPartyIDs *)new FIX::NoTargetPartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTargetPartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTargetPartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTargetPartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTargetPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTargetPartyIDs";
  FIX::NoTargetPartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTargetPartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTargetPartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTargetPartyIDs *)new FIX::NoTargetPartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTargetPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTargetPartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTargetPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTargetPartyIDs.new", 
    "    NoTargetPartyIDs.new()\n"
    "    NoTargetPartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTargetPartyIDs(FIX::NoTargetPartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassNoRootPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoRootPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartyIDs";
  FIX::NoRootPartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRootPartyIDs *)new FIX::NoRootPartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRootPartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRootPartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRootPartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRootPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartyIDs";
  FIX::NoRootPartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoRootPartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoRootPartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRootPartyIDs *)new FIX::NoRootPartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRootPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRootPartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRootPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRootPartyIDs.new", 
    "    NoRootPartyIDs.new()\n"
    "    NoRootPartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRootPartyIDs(FIX::NoRootPartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassEventDate;

SWIGINTERN VALUE
_wrap_new_EventDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EventDate";
  FIX::EventDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EventDate *)new FIX::EventDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EventDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EventDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EventDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EventDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventDate";
  FIX::EventDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::EventDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::EventDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::EventDate *)new FIX::EventDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EventDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EventDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EventDate.new", 
    "    EventDate.new()\n"
    "    EventDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EventDate(FIX::EventDate *arg1) {
    delete arg1;
}

swig_class SwigClassPegRoundDirection;

SWIGINTERN VALUE
_wrap_new_PegRoundDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegRoundDirection";
  FIX::PegRoundDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegRoundDirection *)new FIX::PegRoundDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegRoundDirection_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegRoundDirection_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegRoundDirection);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegRoundDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegRoundDirection";
  FIX::PegRoundDirection *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PegRoundDirection", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PegRoundDirection", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PegRoundDirection *)new FIX::PegRoundDirection((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegRoundDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegRoundDirection__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegRoundDirection__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegRoundDirection.new", 
    "    PegRoundDirection.new()\n"
    "    PegRoundDirection.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegRoundDirection(FIX::PegRoundDirection *arg1) {
    delete arg1;
}

swig_class SwigClassLegSettlDate;

SWIGINTERN VALUE
_wrap_new_LegSettlDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSettlDate";
  FIX::LegSettlDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSettlDate *)new FIX::LegSettlDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSettlDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSettlDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSettlDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSettlDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlDate";
  FIX::LegSettlDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegSettlDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegSettlDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegSettlDate *)new FIX::LegSettlDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSettlDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSettlDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSettlDate.new", 
    "    LegSettlDate.new()\n"
    "    LegSettlDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlDate(FIX::LegSettlDate *arg1) {
    delete arg1;
}

swig_class SwigClassModelType;

SWIGINTERN VALUE
_wrap_new_ModelType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ModelType";
  FIX::ModelType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ModelType *)new FIX::ModelType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ModelType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ModelType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ModelType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ModelType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ModelType";
  FIX::ModelType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ModelType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ModelType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ModelType *)new FIX::ModelType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ModelType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ModelType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ModelType.new", 
    "    ModelType.new()\n"
    "    ModelType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ModelType(FIX::ModelType *arg1) {
    delete arg1;
}

swig_class SwigClassDefaultVerIndicator;

SWIGINTERN VALUE
_wrap_new_DefaultVerIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DefaultVerIndicator";
  FIX::DefaultVerIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DefaultVerIndicator *)new FIX::DefaultVerIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DefaultVerIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DefaultVerIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DefaultVerIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DefaultVerIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultVerIndicator";
  FIX::DefaultVerIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::DefaultVerIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::DefaultVerIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::DefaultVerIndicator *)new FIX::DefaultVerIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefaultVerIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DefaultVerIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultVerIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DefaultVerIndicator.new", 
    "    DefaultVerIndicator.new()\n"
    "    DefaultVerIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultVerIndicator(FIX::DefaultVerIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassFuturesValuationMethod;

SWIGINTERN VALUE
_wrap_new_FuturesValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FuturesValuationMethod";
  FIX::FuturesValuationMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FuturesValuationMethod *)new FIX::FuturesValuationMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FuturesValuationMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FuturesValuationMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FuturesValuationMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FuturesValuationMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FuturesValuationMethod";
  FIX::FuturesValuationMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::FuturesValuationMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::FuturesValuationMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::FuturesValuationMethod *)new FIX::FuturesValuationMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FuturesValuationMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FuturesValuationMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FuturesValuationMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FuturesValuationMethod.new", 
    "    FuturesValuationMethod.new()\n"
    "    FuturesValuationMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FuturesValuationMethod(FIX::FuturesValuationMethod *arg1) {
    delete arg1;
}

swig_class SwigClassSettlMethod;

SWIGINTERN VALUE
_wrap_new_SettlMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlMethod";
  FIX::SettlMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlMethod *)new FIX::SettlMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlMethod";
  FIX::SettlMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlMethod *)new FIX::SettlMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlMethod.new", 
    "    SettlMethod.new()\n"
    "    SettlMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlMethod(FIX::SettlMethod *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingFXRate;

SWIGINTERN VALUE
_wrap_new_UnderlyingFXRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRate";
  FIX::UnderlyingFXRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingFXRate *)new FIX::UnderlyingFXRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingFXRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingFXRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingFXRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingFXRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRate";
  FIX::UnderlyingFXRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::UnderlyingFXRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::UnderlyingFXRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::UnderlyingFXRate *)new FIX::UnderlyingFXRate((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingFXRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingFXRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFXRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingFXRate.new", 
    "    UnderlyingFXRate.new()\n"
    "    UnderlyingFXRate.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFXRate(FIX::UnderlyingFXRate *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmStatus;

SWIGINTERN VALUE
_wrap_new_ConfirmStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmStatus";
  FIX::ConfirmStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmStatus *)new FIX::ConfirmStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmStatus";
  FIX::ConfirmStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ConfirmStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ConfirmStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ConfirmStatus *)new FIX::ConfirmStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmStatus.new", 
    "    ConfirmStatus.new()\n"
    "    ConfirmStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmStatus(FIX::ConfirmStatus *arg1) {
    delete arg1;
}

swig_class SwigClassLocateReqd;

SWIGINTERN VALUE
_wrap_new_LocateReqd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LocateReqd";
  FIX::LocateReqd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LocateReqd *)new FIX::LocateReqd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LocateReqd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LocateReqd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LocateReqd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LocateReqd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocateReqd";
  FIX::LocateReqd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::LocateReqd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::LocateReqd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::LocateReqd *)new FIX::LocateReqd((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LocateReqd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LocateReqd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocateReqd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LocateReqd.new", 
    "    LocateReqd.new()\n"
    "    LocateReqd.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LocateReqd(FIX::LocateReqd *arg1) {
    delete arg1;
}

swig_class SwigClassPosMaintRptID;

SWIGINTERN VALUE
_wrap_new_PosMaintRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptID";
  FIX::PosMaintRptID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosMaintRptID *)new FIX::PosMaintRptID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosMaintRptID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosMaintRptID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosMaintRptID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosMaintRptID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptID";
  FIX::PosMaintRptID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PosMaintRptID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PosMaintRptID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PosMaintRptID *)new FIX::PosMaintRptID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosMaintRptID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosMaintRptID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintRptID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosMaintRptID.new", 
    "    PosMaintRptID.new()\n"
    "    PosMaintRptID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintRptID(FIX::PosMaintRptID *arg1) {
    delete arg1;
}

swig_class SwigClassAdjustment;

SWIGINTERN VALUE
_wrap_new_Adjustment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Adjustment";
  FIX::Adjustment *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Adjustment *)new FIX::Adjustment();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Adjustment_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Adjustment_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Adjustment);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Adjustment__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Adjustment";
  FIX::Adjustment *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Adjustment", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Adjustment", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Adjustment *)new FIX::Adjustment((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Adjustment(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Adjustment__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Adjustment__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Adjustment.new", 
    "    Adjustment.new()\n"
    "    Adjustment.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Adjustment(FIX::Adjustment *arg1) {
    delete arg1;
}

swig_class SwigClassStreamAsgnType;

SWIGINTERN VALUE
_wrap_new_StreamAsgnType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnType";
  FIX::StreamAsgnType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StreamAsgnType *)new FIX::StreamAsgnType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StreamAsgnType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StreamAsgnType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StreamAsgnType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StreamAsgnType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnType";
  FIX::StreamAsgnType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StreamAsgnType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StreamAsgnType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StreamAsgnType *)new FIX::StreamAsgnType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamAsgnType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StreamAsgnType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StreamAsgnType.new", 
    "    StreamAsgnType.new()\n"
    "    StreamAsgnType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnType(FIX::StreamAsgnType *arg1) {
    delete arg1;
}

swig_class SwigClassLastRptRequested;

SWIGINTERN VALUE
_wrap_new_LastRptRequested__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastRptRequested";
  FIX::LastRptRequested *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastRptRequested *)new FIX::LastRptRequested();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastRptRequested_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastRptRequested_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastRptRequested);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastRptRequested__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastRptRequested";
  FIX::LastRptRequested *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::LastRptRequested", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::LastRptRequested", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::LastRptRequested *)new FIX::LastRptRequested((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastRptRequested(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastRptRequested__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastRptRequested__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastRptRequested.new", 
    "    LastRptRequested.new()\n"
    "    LastRptRequested.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastRptRequested(FIX::LastRptRequested *arg1) {
    delete arg1;
}

swig_class SwigClassLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_LocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LocaleOfIssue";
  FIX::LocaleOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LocaleOfIssue *)new FIX::LocaleOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LocaleOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LocaleOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LocaleOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LocaleOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocaleOfIssue";
  FIX::LocaleOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LocaleOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LocaleOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LocaleOfIssue *)new FIX::LocaleOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LocaleOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LocaleOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocaleOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LocaleOfIssue.new", 
    "    LocaleOfIssue.new()\n"
    "    LocaleOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LocaleOfIssue(FIX::LocaleOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassSenderSubID;

SWIGINTERN VALUE
_wrap_new_SenderSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SenderSubID";
  FIX::SenderSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SenderSubID *)new FIX::SenderSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SenderSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SenderSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SenderSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SenderSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderSubID";
  FIX::SenderSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SenderSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SenderSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SenderSubID *)new FIX::SenderSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SenderSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SenderSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SenderSubID.new", 
    "    SenderSubID.new()\n"
    "    SenderSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SenderSubID(FIX::SenderSubID *arg1) {
    delete arg1;
}

swig_class SwigClassHighPx;

SWIGINTERN VALUE
_wrap_new_HighPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HighPx";
  FIX::HighPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HighPx *)new FIX::HighPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HighPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HighPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HighPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HighPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HighPx";
  FIX::HighPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::HighPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::HighPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::HighPx *)new FIX::HighPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HighPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HighPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HighPx.new", 
    "    HighPx.new()\n"
    "    HighPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HighPx(FIX::HighPx *arg1) {
    delete arg1;
}

swig_class SwigClassAllocSettlCurrAmt;

SWIGINTERN VALUE
_wrap_new_AllocSettlCurrAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrAmt";
  FIX::AllocSettlCurrAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocSettlCurrAmt *)new FIX::AllocSettlCurrAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocSettlCurrAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocSettlCurrAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocSettlCurrAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocSettlCurrAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrAmt";
  FIX::AllocSettlCurrAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::AllocSettlCurrAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::AllocSettlCurrAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::AllocSettlCurrAmt *)new FIX::AllocSettlCurrAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocSettlCurrAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocSettlCurrAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocSettlCurrAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocSettlCurrAmt.new", 
    "    AllocSettlCurrAmt.new()\n"
    "    AllocSettlCurrAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocSettlCurrAmt(FIX::AllocSettlCurrAmt *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventPriceBoundaryPrecision;

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryPrecision";
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventPriceBoundaryPrecision *)new FIX::ComplexEventPriceBoundaryPrecision();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryPrecision_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventPriceBoundaryPrecision_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryPrecision";
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::ComplexEventPriceBoundaryPrecision", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::ComplexEventPriceBoundaryPrecision", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::ComplexEventPriceBoundaryPrecision *)new FIX::ComplexEventPriceBoundaryPrecision((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventPriceBoundaryPrecision(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventPriceBoundaryPrecision.new", 
    "    ComplexEventPriceBoundaryPrecision.new()\n"
    "    ComplexEventPriceBoundaryPrecision.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPriceBoundaryPrecision(FIX::ComplexEventPriceBoundaryPrecision *arg1) {
    delete arg1;
}

swig_class SwigClassInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_InstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyRole";
  FIX::InstrumentPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrumentPartyRole *)new FIX::InstrumentPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrumentPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrumentPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrumentPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrumentPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyRole";
  FIX::InstrumentPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::InstrumentPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::InstrumentPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::InstrumentPartyRole *)new FIX::InstrumentPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrumentPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrumentPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrumentPartyRole.new", 
    "    InstrumentPartyRole.new()\n"
    "    InstrumentPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartyRole(FIX::InstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassYieldRedemptionPrice;

SWIGINTERN VALUE
_wrap_new_YieldRedemptionPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPrice";
  FIX::YieldRedemptionPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::YieldRedemptionPrice *)new FIX::YieldRedemptionPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_YieldRedemptionPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_YieldRedemptionPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__YieldRedemptionPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_YieldRedemptionPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPrice";
  FIX::YieldRedemptionPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::YieldRedemptionPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::YieldRedemptionPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::YieldRedemptionPrice *)new FIX::YieldRedemptionPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_YieldRedemptionPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_YieldRedemptionPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldRedemptionPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "YieldRedemptionPrice.new", 
    "    YieldRedemptionPrice.new()\n"
    "    YieldRedemptionPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldRedemptionPrice(FIX::YieldRedemptionPrice *arg1) {
    delete arg1;
}

swig_class SwigClassCumQty;

SWIGINTERN VALUE
_wrap_new_CumQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CumQty";
  FIX::CumQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CumQty *)new FIX::CumQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CumQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CumQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CumQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CumQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CumQty";
  FIX::CumQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::CumQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::CumQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::CumQty *)new FIX::CumQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CumQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CumQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CumQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CumQty.new", 
    "    CumQty.new()\n"
    "    CumQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CumQty(FIX::CumQty *arg1) {
    delete arg1;
}

swig_class SwigClassOrigClOrdID;

SWIGINTERN VALUE
_wrap_new_OrigClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigClOrdID";
  FIX::OrigClOrdID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigClOrdID *)new FIX::OrigClOrdID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigClOrdID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigClOrdID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigClOrdID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigClOrdID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigClOrdID";
  FIX::OrigClOrdID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrigClOrdID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrigClOrdID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrigClOrdID *)new FIX::OrigClOrdID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigClOrdID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigClOrdID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigClOrdID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigClOrdID.new", 
    "    OrigClOrdID.new()\n"
    "    OrigClOrdID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigClOrdID(FIX::OrigClOrdID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlSessID;

SWIGINTERN VALUE
_wrap_new_SettlSessID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlSessID";
  FIX::SettlSessID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlSessID *)new FIX::SettlSessID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlSessID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlSessID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlSessID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlSessID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlSessID";
  FIX::SettlSessID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlSessID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlSessID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlSessID *)new FIX::SettlSessID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlSessID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlSessID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlSessID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlSessID.new", 
    "    SettlSessID.new()\n"
    "    SettlSessID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlSessID(FIX::SettlSessID *arg1) {
    delete arg1;
}

swig_class SwigClassParentMktSegmID;

SWIGINTERN VALUE
_wrap_new_ParentMktSegmID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ParentMktSegmID";
  FIX::ParentMktSegmID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ParentMktSegmID *)new FIX::ParentMktSegmID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ParentMktSegmID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ParentMktSegmID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ParentMktSegmID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ParentMktSegmID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ParentMktSegmID";
  FIX::ParentMktSegmID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ParentMktSegmID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ParentMktSegmID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ParentMktSegmID *)new FIX::ParentMktSegmID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ParentMktSegmID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ParentMktSegmID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ParentMktSegmID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ParentMktSegmID.new", 
    "    ParentMktSegmID.new()\n"
    "    ParentMktSegmID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ParentMktSegmID(FIX::ParentMktSegmID *arg1) {
    delete arg1;
}

swig_class SwigClassTradeReportType;

SWIGINTERN VALUE
_wrap_new_TradeReportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeReportType";
  FIX::TradeReportType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeReportType *)new FIX::TradeReportType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeReportType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeReportType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeReportType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeReportType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportType";
  FIX::TradeReportType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradeReportType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradeReportType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradeReportType *)new FIX::TradeReportType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeReportType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeReportType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeReportType.new", 
    "    TradeReportType.new()\n"
    "    TradeReportType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportType(FIX::TradeReportType *arg1) {
    delete arg1;
}

swig_class SwigClassAvgPrxPrecision;

SWIGINTERN VALUE
_wrap_new_AvgPrxPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AvgPrxPrecision";
  FIX::AvgPrxPrecision *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AvgPrxPrecision *)new FIX::AvgPrxPrecision();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AvgPrxPrecision_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AvgPrxPrecision_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AvgPrxPrecision);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AvgPrxPrecision__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPrxPrecision";
  FIX::AvgPrxPrecision *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AvgPrxPrecision", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AvgPrxPrecision", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AvgPrxPrecision *)new FIX::AvgPrxPrecision((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AvgPrxPrecision(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AvgPrxPrecision__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPrxPrecision__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AvgPrxPrecision.new", 
    "    AvgPrxPrecision.new()\n"
    "    AvgPrxPrecision.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPrxPrecision(FIX::AvgPrxPrecision *arg1) {
    delete arg1;
}

swig_class SwigClassNoLegs;

SWIGINTERN VALUE
_wrap_new_NoLegs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoLegs";
  FIX::NoLegs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoLegs *)new FIX::NoLegs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoLegs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoLegs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoLegs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoLegs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegs";
  FIX::NoLegs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoLegs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoLegs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoLegs *)new FIX::NoLegs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoLegs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoLegs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoLegs.new", 
    "    NoLegs.new()\n"
    "    NoLegs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegs(FIX::NoLegs *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSymbol;

SWIGINTERN VALUE
_wrap_new_UnderlyingSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbol";
  FIX::UnderlyingSymbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSymbol *)new FIX::UnderlyingSymbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSymbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSymbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSymbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbol";
  FIX::UnderlyingSymbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSymbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSymbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSymbol *)new FIX::UnderlyingSymbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSymbol.new", 
    "    UnderlyingSymbol.new()\n"
    "    UnderlyingSymbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSymbol(FIX::UnderlyingSymbol *arg1) {
    delete arg1;
}

swig_class SwigClassExerciseStyle;

SWIGINTERN VALUE
_wrap_new_ExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExerciseStyle";
  FIX::ExerciseStyle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExerciseStyle *)new FIX::ExerciseStyle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExerciseStyle_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExerciseStyle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExerciseStyle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExerciseStyle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExerciseStyle";
  FIX::ExerciseStyle *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ExerciseStyle", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ExerciseStyle", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ExerciseStyle *)new FIX::ExerciseStyle((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExerciseStyle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExerciseStyle__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExerciseStyle__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExerciseStyle.new", 
    "    ExerciseStyle.new()\n"
    "    ExerciseStyle.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExerciseStyle(FIX::ExerciseStyle *arg1) {
    delete arg1;
}

swig_class SwigClassHaltReasonChar;

SWIGINTERN VALUE
_wrap_new_HaltReasonChar__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonChar";
  FIX::HaltReasonChar *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HaltReasonChar *)new FIX::HaltReasonChar();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HaltReasonChar_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HaltReasonChar_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HaltReasonChar);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HaltReasonChar__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonChar";
  FIX::HaltReasonChar *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::HaltReasonChar", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::HaltReasonChar", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::HaltReasonChar *)new FIX::HaltReasonChar((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HaltReasonChar(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HaltReasonChar__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HaltReasonChar__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HaltReasonChar.new", 
    "    HaltReasonChar.new()\n"
    "    HaltReasonChar.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HaltReasonChar(FIX::HaltReasonChar *arg1) {
    delete arg1;
}

swig_class SwigClassExDestination;

SWIGINTERN VALUE
_wrap_new_ExDestination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExDestination";
  FIX::ExDestination *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExDestination *)new FIX::ExDestination();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExDestination_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExDestination_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExDestination);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExDestination__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDestination";
  FIX::ExDestination *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::ExDestination", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::ExDestination", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::ExDestination *)new FIX::ExDestination((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExDestination(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExDestination__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExDestination__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExDestination.new", 
    "    ExDestination.new()\n"
    "    ExDestination.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExDestination(FIX::ExDestination *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrmtAssignmentMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrmtAssignmentMethod";
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrmtAssignmentMethod *)new FIX::DerivativeInstrmtAssignmentMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrmtAssignmentMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrmtAssignmentMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrmtAssignmentMethod";
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DerivativeInstrmtAssignmentMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DerivativeInstrmtAssignmentMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DerivativeInstrmtAssignmentMethod *)new FIX::DerivativeInstrmtAssignmentMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrmtAssignmentMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrmtAssignmentMethod.new", 
    "    DerivativeInstrmtAssignmentMethod.new()\n"
    "    DerivativeInstrmtAssignmentMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrmtAssignmentMethod(FIX::DerivativeInstrmtAssignmentMethod *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIDSource";
  FIX::UnderlyingIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingIDSource *)new FIX::UnderlyingIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIDSource";
  FIX::UnderlyingIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingIDSource *)new FIX::UnderlyingIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingIDSource.new", 
    "    UnderlyingIDSource.new()\n"
    "    UnderlyingIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingIDSource(FIX::UnderlyingIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassAdvId;

SWIGINTERN VALUE
_wrap_new_AdvId__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AdvId";
  FIX::AdvId *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AdvId *)new FIX::AdvId();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AdvId_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AdvId_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AdvId);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AdvId__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvId";
  FIX::AdvId *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AdvId", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AdvId", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AdvId *)new FIX::AdvId((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AdvId(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AdvId__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvId__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AdvId.new", 
    "    AdvId.new()\n"
    "    AdvId.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvId(FIX::AdvId *arg1) {
    delete arg1;
}

swig_class SwigClassTransBkdTime;

SWIGINTERN VALUE
_wrap_new_TransBkdTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  FIX::TransBkdTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TransBkdTime *)new FIX::TransBkdTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TransBkdTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  FIX::TransBkdTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TransBkdTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TransBkdTime *)new FIX::TransBkdTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TransBkdTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  FIX::TransBkdTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TransBkdTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TransBkdTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TransBkdTime *)new FIX::TransBkdTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TransBkdTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TransBkdTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TransBkdTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TransBkdTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  FIX::TransBkdTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TransBkdTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TransBkdTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TransBkdTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TransBkdTime *)new FIX::TransBkdTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TransBkdTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TransBkdTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransBkdTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TransBkdTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TransBkdTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TransBkdTime.new", 
    "    TransBkdTime.new()\n"
    "    TransBkdTime.new(bool showMilliseconds)\n"
    "    TransBkdTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TransBkdTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TransBkdTime(FIX::TransBkdTime *arg1) {
    delete arg1;
}

swig_class SwigClassLegLastPx;

SWIGINTERN VALUE
_wrap_new_LegLastPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegLastPx";
  FIX::LegLastPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegLastPx *)new FIX::LegLastPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegLastPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegLastPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegLastPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegLastPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastPx";
  FIX::LegLastPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LegLastPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LegLastPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LegLastPx *)new FIX::LegLastPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegLastPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegLastPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLastPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegLastPx.new", 
    "    LegLastPx.new()\n"
    "    LegLastPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLastPx(FIX::LegLastPx *arg1) {
    delete arg1;
}

swig_class SwigClassAllocReportType;

SWIGINTERN VALUE
_wrap_new_AllocReportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocReportType";
  FIX::AllocReportType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocReportType *)new FIX::AllocReportType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocReportType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocReportType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocReportType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocReportType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportType";
  FIX::AllocReportType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocReportType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocReportType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocReportType *)new FIX::AllocReportType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocReportType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocReportType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocReportType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocReportType.new", 
    "    AllocReportType.new()\n"
    "    AllocReportType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocReportType(FIX::AllocReportType *arg1) {
    delete arg1;
}

swig_class SwigClassRegistDtls;

SWIGINTERN VALUE
_wrap_new_RegistDtls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistDtls";
  FIX::RegistDtls *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistDtls *)new FIX::RegistDtls();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistDtls_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistDtls_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistDtls);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistDtls__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistDtls";
  FIX::RegistDtls *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistDtls", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistDtls", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistDtls *)new FIX::RegistDtls((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistDtls(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistDtls__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistDtls__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistDtls.new", 
    "    RegistDtls.new()\n"
    "    RegistDtls.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistDtls(FIX::RegistDtls *arg1) {
    delete arg1;
}

swig_class SwigClassAllocType;

SWIGINTERN VALUE
_wrap_new_AllocType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocType";
  FIX::AllocType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocType *)new FIX::AllocType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocType";
  FIX::AllocType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocType *)new FIX::AllocType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocType.new", 
    "    AllocType.new()\n"
    "    AllocType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocType(FIX::AllocType *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteRequestRejectReason;

SWIGINTERN VALUE
_wrap_new_QuoteRequestRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestRejectReason";
  FIX::QuoteRequestRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteRequestRejectReason *)new FIX::QuoteRequestRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteRequestRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteRequestRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteRequestRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestRejectReason";
  FIX::QuoteRequestRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteRequestRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteRequestRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteRequestRejectReason *)new FIX::QuoteRequestRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteRequestRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteRequestRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRequestRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteRequestRejectReason.new", 
    "    QuoteRequestRejectReason.new()\n"
    "    QuoteRequestRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRequestRejectReason(FIX::QuoteRequestRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_UnderlyingUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasure";
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingUnitOfMeasure *)new FIX::UnderlyingUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasure";
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingUnitOfMeasure *)new FIX::UnderlyingUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingUnitOfMeasure.new", 
    "    UnderlyingUnitOfMeasure.new()\n"
    "    UnderlyingUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingUnitOfMeasure(FIX::UnderlyingUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassIndividualAllocID;

SWIGINTERN VALUE
_wrap_new_IndividualAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocID";
  FIX::IndividualAllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IndividualAllocID *)new FIX::IndividualAllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IndividualAllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IndividualAllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IndividualAllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IndividualAllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocID";
  FIX::IndividualAllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IndividualAllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IndividualAllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IndividualAllocID *)new FIX::IndividualAllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IndividualAllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IndividualAllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndividualAllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IndividualAllocID.new", 
    "    IndividualAllocID.new()\n"
    "    IndividualAllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IndividualAllocID(FIX::IndividualAllocID *arg1) {
    delete arg1;
}

swig_class SwigClassLegOfferPx;

SWIGINTERN VALUE
_wrap_new_LegOfferPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegOfferPx";
  FIX::LegOfferPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegOfferPx *)new FIX::LegOfferPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegOfferPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegOfferPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegOfferPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegOfferPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOfferPx";
  FIX::LegOfferPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LegOfferPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LegOfferPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LegOfferPx *)new FIX::LegOfferPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegOfferPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegOfferPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOfferPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegOfferPx.new", 
    "    LegOfferPx.new()\n"
    "    LegOfferPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOfferPx(FIX::LegOfferPx *arg1) {
    delete arg1;
}

swig_class SwigClassLiquidityIndType;

SWIGINTERN VALUE
_wrap_new_LiquidityIndType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LiquidityIndType";
  FIX::LiquidityIndType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LiquidityIndType *)new FIX::LiquidityIndType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LiquidityIndType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LiquidityIndType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LiquidityIndType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LiquidityIndType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityIndType";
  FIX::LiquidityIndType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LiquidityIndType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LiquidityIndType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LiquidityIndType *)new FIX::LiquidityIndType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LiquidityIndType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LiquidityIndType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityIndType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LiquidityIndType.new", 
    "    LiquidityIndType.new()\n"
    "    LiquidityIndType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityIndType(FIX::LiquidityIndType *arg1) {
    delete arg1;
}

swig_class SwigClassHopSendingTime;

SWIGINTERN VALUE
_wrap_new_HopSendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  FIX::HopSendingTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HopSendingTime *)new FIX::HopSendingTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_HopSendingTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  FIX::HopSendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::HopSendingTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::HopSendingTime *)new FIX::HopSendingTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_HopSendingTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  FIX::HopSendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::HopSendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::HopSendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::HopSendingTime *)new FIX::HopSendingTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HopSendingTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HopSendingTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HopSendingTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HopSendingTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  FIX::HopSendingTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::HopSendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::HopSendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::HopSendingTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::HopSendingTime *)new FIX::HopSendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HopSendingTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HopSendingTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HopSendingTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HopSendingTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HopSendingTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "HopSendingTime.new", 
    "    HopSendingTime.new()\n"
    "    HopSendingTime.new(bool showMilliseconds)\n"
    "    HopSendingTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    HopSendingTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HopSendingTime(FIX::HopSendingTime *arg1) {
    delete arg1;
}

swig_class SwigClassApplResendFlag;

SWIGINTERN VALUE
_wrap_new_ApplResendFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplResendFlag";
  FIX::ApplResendFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplResendFlag *)new FIX::ApplResendFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplResendFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplResendFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplResendFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplResendFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResendFlag";
  FIX::ApplResendFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ApplResendFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ApplResendFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ApplResendFlag *)new FIX::ApplResendFlag((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplResendFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplResendFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResendFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplResendFlag.new", 
    "    ApplResendFlag.new()\n"
    "    ApplResendFlag.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResendFlag(FIX::ApplResendFlag *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeCapPrice;

SWIGINTERN VALUE
_wrap_new_DerivativeCapPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCapPrice";
  FIX::DerivativeCapPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeCapPrice *)new FIX::DerivativeCapPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeCapPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeCapPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeCapPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeCapPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCapPrice";
  FIX::DerivativeCapPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::DerivativeCapPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::DerivativeCapPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::DerivativeCapPrice *)new FIX::DerivativeCapPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeCapPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeCapPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeCapPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeCapPrice.new", 
    "    DerivativeCapPrice.new()\n"
    "    DerivativeCapPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeCapPrice(FIX::DerivativeCapPrice *arg1) {
    delete arg1;
}

swig_class SwigClassComplexOptPayoutAmount;

SWIGINTERN VALUE
_wrap_new_ComplexOptPayoutAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexOptPayoutAmount";
  FIX::ComplexOptPayoutAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexOptPayoutAmount *)new FIX::ComplexOptPayoutAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexOptPayoutAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexOptPayoutAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexOptPayoutAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexOptPayoutAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexOptPayoutAmount";
  FIX::ComplexOptPayoutAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::ComplexOptPayoutAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::ComplexOptPayoutAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::ComplexOptPayoutAmount *)new FIX::ComplexOptPayoutAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexOptPayoutAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexOptPayoutAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexOptPayoutAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexOptPayoutAmount.new", 
    "    ComplexOptPayoutAmount.new()\n"
    "    ComplexOptPayoutAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexOptPayoutAmount(FIX::ComplexOptPayoutAmount *arg1) {
    delete arg1;
}

swig_class SwigClassLanguageCode;

SWIGINTERN VALUE
_wrap_new_LanguageCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LanguageCode";
  FIX::LanguageCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LanguageCode *)new FIX::LanguageCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LanguageCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LanguageCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LanguageCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LanguageCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LANGUAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LanguageCode";
  FIX::LanguageCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LANGUAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LANGUAGE const &","FIX::LanguageCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LANGUAGE const &","FIX::LanguageCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LANGUAGE * >(argp1);
  result = (FIX::LanguageCode *)new FIX::LanguageCode((FIX::LANGUAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LanguageCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LanguageCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LANGUAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LanguageCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LanguageCode.new", 
    "    LanguageCode.new()\n"
    "    LanguageCode.new(FIX::LANGUAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LanguageCode(FIX::LanguageCode *arg1) {
    delete arg1;
}

swig_class SwigClassSettlObligRefID;

SWIGINTERN VALUE
_wrap_new_SettlObligRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlObligRefID";
  FIX::SettlObligRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlObligRefID *)new FIX::SettlObligRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlObligRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlObligRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlObligRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlObligRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligRefID";
  FIX::SettlObligRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlObligRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlObligRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlObligRefID *)new FIX::SettlObligRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlObligRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlObligRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlObligRefID.new", 
    "    SettlObligRefID.new()\n"
    "    SettlObligRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligRefID(FIX::SettlObligRefID *arg1) {
    delete arg1;
}

swig_class SwigClassOrigTradeID;

SWIGINTERN VALUE
_wrap_new_OrigTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeID";
  FIX::OrigTradeID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigTradeID *)new FIX::OrigTradeID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigTradeID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigTradeID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigTradeID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigTradeID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeID";
  FIX::OrigTradeID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrigTradeID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrigTradeID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrigTradeID *)new FIX::OrigTradeID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigTradeID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigTradeID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTradeID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigTradeID.new", 
    "    OrigTradeID.new()\n"
    "    OrigTradeID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTradeID(FIX::OrigTradeID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCollectAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingCollectAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCollectAmount";
  FIX::UnderlyingCollectAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCollectAmount *)new FIX::UnderlyingCollectAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCollectAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCollectAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCollectAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCollectAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCollectAmount";
  FIX::UnderlyingCollectAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingCollectAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingCollectAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingCollectAmount *)new FIX::UnderlyingCollectAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCollectAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCollectAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCollectAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCollectAmount.new", 
    "    UnderlyingCollectAmount.new()\n"
    "    UnderlyingCollectAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCollectAmount(FIX::UnderlyingCollectAmount *arg1) {
    delete arg1;
}

swig_class SwigClassStatusValue;

SWIGINTERN VALUE
_wrap_new_StatusValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StatusValue";
  FIX::StatusValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StatusValue *)new FIX::StatusValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StatusValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StatusValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StatusValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StatusValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatusValue";
  FIX::StatusValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StatusValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StatusValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StatusValue *)new FIX::StatusValue((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StatusValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StatusValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StatusValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StatusValue.new", 
    "    StatusValue.new()\n"
    "    StatusValue.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StatusValue(FIX::StatusValue *arg1) {
    delete arg1;
}

swig_class SwigClassOfferSpotRate;

SWIGINTERN VALUE
_wrap_new_OfferSpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OfferSpotRate";
  FIX::OfferSpotRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OfferSpotRate *)new FIX::OfferSpotRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OfferSpotRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OfferSpotRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OfferSpotRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OfferSpotRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSpotRate";
  FIX::OfferSpotRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::OfferSpotRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::OfferSpotRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::OfferSpotRate *)new FIX::OfferSpotRate((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OfferSpotRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OfferSpotRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferSpotRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OfferSpotRate.new", 
    "    OfferSpotRate.new()\n"
    "    OfferSpotRate.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferSpotRate(FIX::OfferSpotRate *arg1) {
    delete arg1;
}

swig_class SwigClassPosType;

SWIGINTERN VALUE
_wrap_new_PosType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosType";
  FIX::PosType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosType *)new FIX::PosType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosType";
  FIX::PosType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PosType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PosType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PosType *)new FIX::PosType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosType.new", 
    "    PosType.new()\n"
    "    PosType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosType(FIX::PosType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingRedemptionDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingRedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRedemptionDate";
  FIX::UnderlyingRedemptionDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingRedemptionDate *)new FIX::UnderlyingRedemptionDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingRedemptionDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingRedemptionDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingRedemptionDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingRedemptionDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRedemptionDate";
  FIX::UnderlyingRedemptionDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::UnderlyingRedemptionDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::UnderlyingRedemptionDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::UnderlyingRedemptionDate *)new FIX::UnderlyingRedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingRedemptionDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingRedemptionDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRedemptionDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingRedemptionDate.new", 
    "    UnderlyingRedemptionDate.new()\n"
    "    UnderlyingRedemptionDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRedemptionDate(FIX::UnderlyingRedemptionDate *arg1) {
    delete arg1;
}

swig_class SwigClassSettlDepositoryCode;

SWIGINTERN VALUE
_wrap_new_SettlDepositoryCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlDepositoryCode";
  FIX::SettlDepositoryCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlDepositoryCode *)new FIX::SettlDepositoryCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlDepositoryCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlDepositoryCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlDepositoryCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlDepositoryCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDepositoryCode";
  FIX::SettlDepositoryCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlDepositoryCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlDepositoryCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlDepositoryCode *)new FIX::SettlDepositoryCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlDepositoryCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlDepositoryCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDepositoryCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlDepositoryCode.new", 
    "    SettlDepositoryCode.new()\n"
    "    SettlDepositoryCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDepositoryCode(FIX::SettlDepositoryCode *arg1) {
    delete arg1;
}

swig_class SwigClassStreamAsgnAckType;

SWIGINTERN VALUE
_wrap_new_StreamAsgnAckType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnAckType";
  FIX::StreamAsgnAckType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StreamAsgnAckType *)new FIX::StreamAsgnAckType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StreamAsgnAckType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StreamAsgnAckType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StreamAsgnAckType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StreamAsgnAckType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnAckType";
  FIX::StreamAsgnAckType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::StreamAsgnAckType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::StreamAsgnAckType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::StreamAsgnAckType *)new FIX::StreamAsgnAckType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamAsgnAckType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StreamAsgnAckType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnAckType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StreamAsgnAckType.new", 
    "    StreamAsgnAckType.new()\n"
    "    StreamAsgnAckType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnAckType(FIX::StreamAsgnAckType *arg1) {
    delete arg1;
}

swig_class SwigClassFloorPrice;

SWIGINTERN VALUE
_wrap_new_FloorPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FloorPrice";
  FIX::FloorPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FloorPrice *)new FIX::FloorPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FloorPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FloorPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FloorPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FloorPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FloorPrice";
  FIX::FloorPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::FloorPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::FloorPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::FloorPrice *)new FIX::FloorPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FloorPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FloorPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FloorPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FloorPrice.new", 
    "    FloorPrice.new()\n"
    "    FloorPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FloorPrice(FIX::FloorPrice *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingPriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasureQty";
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingPriceUnitOfMeasureQty *)new FIX::UnderlyingPriceUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingPriceUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingPriceUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasureQty";
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::UnderlyingPriceUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::UnderlyingPriceUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::UnderlyingPriceUnitOfMeasureQty *)new FIX::UnderlyingPriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingPriceUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingPriceUnitOfMeasureQty.new", 
    "    UnderlyingPriceUnitOfMeasureQty.new()\n"
    "    UnderlyingPriceUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPriceUnitOfMeasureQty(FIX::UnderlyingPriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassFeeMultiplier;

SWIGINTERN VALUE
_wrap_new_FeeMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FeeMultiplier";
  FIX::FeeMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FeeMultiplier *)new FIX::FeeMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FeeMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FeeMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FeeMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FeeMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FeeMultiplier";
  FIX::FeeMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::FeeMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::FeeMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::FeeMultiplier *)new FIX::FeeMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FeeMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FeeMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FeeMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FeeMultiplier.new", 
    "    FeeMultiplier.new()\n"
    "    FeeMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FeeMultiplier(FIX::FeeMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingMaturityTime;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityTime";
  FIX::UnderlyingMaturityTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingMaturityTime *)new FIX::UnderlyingMaturityTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingMaturityTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingMaturityTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingMaturityTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityTime";
  FIX::UnderlyingMaturityTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TZTIMEONLY const &","FIX::UnderlyingMaturityTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TZTIMEONLY const &","FIX::UnderlyingMaturityTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::UnderlyingMaturityTime *)new FIX::UnderlyingMaturityTime((FIX::TZTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingMaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingMaturityTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingMaturityTime.new", 
    "    UnderlyingMaturityTime.new()\n"
    "    UnderlyingMaturityTime.new(FIX::TZTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityTime(FIX::UnderlyingMaturityTime *arg1) {
    delete arg1;
}

swig_class SwigClassApplID;

SWIGINTERN VALUE
_wrap_new_ApplID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplID";
  FIX::ApplID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplID *)new FIX::ApplID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplID";
  FIX::ApplID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ApplID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ApplID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ApplID *)new FIX::ApplID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplID.new", 
    "    ApplID.new()\n"
    "    ApplID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplID(FIX::ApplID *arg1) {
    delete arg1;
}

swig_class SwigClassLegGrossTradeAmt;

SWIGINTERN VALUE
_wrap_new_LegGrossTradeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegGrossTradeAmt";
  FIX::LegGrossTradeAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegGrossTradeAmt *)new FIX::LegGrossTradeAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegGrossTradeAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegGrossTradeAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegGrossTradeAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegGrossTradeAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegGrossTradeAmt";
  FIX::LegGrossTradeAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::LegGrossTradeAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::LegGrossTradeAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::LegGrossTradeAmt *)new FIX::LegGrossTradeAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegGrossTradeAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegGrossTradeAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegGrossTradeAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegGrossTradeAmt.new", 
    "    LegGrossTradeAmt.new()\n"
    "    LegGrossTradeAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegGrossTradeAmt(FIX::LegGrossTradeAmt *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryDate;

SWIGINTERN VALUE
_wrap_new_MDEntryDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryDate";
  FIX::MDEntryDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryDate *)new FIX::MDEntryDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::UTCDATEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryDate";
  FIX::MDEntryDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCDATEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCDATEONLY const &","FIX::MDEntryDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCDATEONLY const &","FIX::MDEntryDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCDATEONLY * >(argp1);
  result = (FIX::MDEntryDate *)new FIX::MDEntryDate((FIX::UTCDATEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCDATEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryDate.new", 
    "    MDEntryDate.new()\n"
    "    MDEntryDate.new(FIX::UTCDATEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryDate(FIX::MDEntryDate *arg1) {
    delete arg1;
}

swig_class SwigClassLegBenchmarkCurveCurrency;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurveCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveCurrency";
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBenchmarkCurveCurrency *)new FIX::LegBenchmarkCurveCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBenchmarkCurveCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBenchmarkCurveCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurveCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveCurrency";
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::LegBenchmarkCurveCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::LegBenchmarkCurveCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::LegBenchmarkCurveCurrency *)new FIX::LegBenchmarkCurveCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBenchmarkCurveCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBenchmarkCurveCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkCurveCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBenchmarkCurveCurrency.new", 
    "    LegBenchmarkCurveCurrency.new()\n"
    "    LegBenchmarkCurveCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkCurveCurrency(FIX::LegBenchmarkCurveCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassOptPayoutAmount;

SWIGINTERN VALUE
_wrap_new_OptPayoutAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutAmount";
  FIX::OptPayoutAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OptPayoutAmount *)new FIX::OptPayoutAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OptPayoutAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OptPayoutAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OptPayoutAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OptPayoutAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutAmount";
  FIX::OptPayoutAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::OptPayoutAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::OptPayoutAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::OptPayoutAmount *)new FIX::OptPayoutAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OptPayoutAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OptPayoutAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptPayoutAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OptPayoutAmount.new", 
    "    OptPayoutAmount.new()\n"
    "    OptPayoutAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OptPayoutAmount(FIX::OptPayoutAmount *arg1) {
    delete arg1;
}

swig_class SwigClassMiscFeeBasis;

SWIGINTERN VALUE
_wrap_new_MiscFeeBasis__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeBasis";
  FIX::MiscFeeBasis *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MiscFeeBasis *)new FIX::MiscFeeBasis();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MiscFeeBasis_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MiscFeeBasis_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MiscFeeBasis);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MiscFeeBasis__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeBasis";
  FIX::MiscFeeBasis *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MiscFeeBasis", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MiscFeeBasis", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MiscFeeBasis *)new FIX::MiscFeeBasis((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MiscFeeBasis(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MiscFeeBasis__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeBasis__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MiscFeeBasis.new", 
    "    MiscFeeBasis.new()\n"
    "    MiscFeeBasis.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeBasis(FIX::MiscFeeBasis *arg1) {
    delete arg1;
}

swig_class SwigClassValidUntilTime;

SWIGINTERN VALUE
_wrap_new_ValidUntilTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  FIX::ValidUntilTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ValidUntilTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  FIX::ValidUntilTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ValidUntilTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ValidUntilTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  FIX::ValidUntilTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ValidUntilTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ValidUntilTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ValidUntilTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ValidUntilTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ValidUntilTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ValidUntilTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  FIX::ValidUntilTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ValidUntilTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ValidUntilTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ValidUntilTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ValidUntilTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ValidUntilTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ValidUntilTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ValidUntilTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ValidUntilTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ValidUntilTime.new", 
    "    ValidUntilTime.new()\n"
    "    ValidUntilTime.new(bool showMilliseconds)\n"
    "    ValidUntilTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    ValidUntilTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ValidUntilTime(FIX::ValidUntilTime *arg1) {
    delete arg1;
}

swig_class SwigClassOrdType;

SWIGINTERN VALUE
_wrap_new_OrdType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrdType";
  FIX::OrdType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrdType *)new FIX::OrdType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrdType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrdType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrdType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrdType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdType";
  FIX::OrdType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::OrdType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::OrdType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::OrdType *)new FIX::OrdType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrdType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrdType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrdType.new", 
    "    OrdType.new()\n"
    "    OrdType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdType(FIX::OrdType *arg1) {
    delete arg1;
}

swig_class SwigClassAdvRefID;

SWIGINTERN VALUE
_wrap_new_AdvRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AdvRefID";
  FIX::AdvRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AdvRefID *)new FIX::AdvRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AdvRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AdvRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AdvRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AdvRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvRefID";
  FIX::AdvRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AdvRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AdvRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AdvRefID *)new FIX::AdvRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AdvRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AdvRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AdvRefID.new", 
    "    AdvRefID.new()\n"
    "    AdvRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvRefID(FIX::AdvRefID *arg1) {
    delete arg1;
}

swig_class SwigClassHopCompID;

SWIGINTERN VALUE
_wrap_new_HopCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::HopCompID";
  FIX::HopCompID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::HopCompID *)new FIX::HopCompID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_HopCompID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_HopCompID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__HopCompID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_HopCompID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopCompID";
  FIX::HopCompID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::HopCompID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::HopCompID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::HopCompID *)new FIX::HopCompID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HopCompID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_HopCompID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HopCompID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HopCompID.new", 
    "    HopCompID.new()\n"
    "    HopCompID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_HopCompID(FIX::HopCompID *arg1) {
    delete arg1;
}

swig_class SwigClassPosMaintRptRefID;

SWIGINTERN VALUE
_wrap_new_PosMaintRptRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptRefID";
  FIX::PosMaintRptRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosMaintRptRefID *)new FIX::PosMaintRptRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosMaintRptRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosMaintRptRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosMaintRptRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosMaintRptRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptRefID";
  FIX::PosMaintRptRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PosMaintRptRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PosMaintRptRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PosMaintRptRefID *)new FIX::PosMaintRptRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosMaintRptRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosMaintRptRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintRptRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosMaintRptRefID.new", 
    "    PosMaintRptRefID.new()\n"
    "    PosMaintRptRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintRptRefID(FIX::PosMaintRptRefID *arg1) {
    delete arg1;
}

swig_class SwigClassLegStipulationValue;

SWIGINTERN VALUE
_wrap_new_LegStipulationValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationValue";
  FIX::LegStipulationValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegStipulationValue *)new FIX::LegStipulationValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegStipulationValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegStipulationValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegStipulationValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegStipulationValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationValue";
  FIX::LegStipulationValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegStipulationValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegStipulationValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegStipulationValue *)new FIX::LegStipulationValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegStipulationValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegStipulationValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStipulationValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegStipulationValue.new", 
    "    LegStipulationValue.new()\n"
    "    LegStipulationValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStipulationValue(FIX::LegStipulationValue *arg1) {
    delete arg1;
}

swig_class SwigClassMatchType;

SWIGINTERN VALUE
_wrap_new_MatchType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MatchType";
  FIX::MatchType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MatchType *)new FIX::MatchType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MatchType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MatchType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MatchType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MatchType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchType";
  FIX::MatchType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MatchType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MatchType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MatchType *)new FIX::MatchType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MatchType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MatchType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MatchType.new", 
    "    MatchType.new()\n"
    "    MatchType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchType(FIX::MatchType *arg1) {
    delete arg1;
}

swig_class SwigClassOptPayoutType;

SWIGINTERN VALUE
_wrap_new_OptPayoutType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutType";
  FIX::OptPayoutType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OptPayoutType *)new FIX::OptPayoutType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OptPayoutType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OptPayoutType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OptPayoutType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OptPayoutType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutType";
  FIX::OptPayoutType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OptPayoutType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OptPayoutType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OptPayoutType *)new FIX::OptPayoutType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OptPayoutType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OptPayoutType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptPayoutType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OptPayoutType.new", 
    "    OptPayoutType.new()\n"
    "    OptPayoutType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OptPayoutType(FIX::OptPayoutType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingPriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasure";
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingPriceUnitOfMeasure *)new FIX::UnderlyingPriceUnitOfMeasure();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingPriceUnitOfMeasure_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingPriceUnitOfMeasure_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasure";
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingPriceUnitOfMeasure", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingPriceUnitOfMeasure", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingPriceUnitOfMeasure *)new FIX::UnderlyingPriceUnitOfMeasure((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingPriceUnitOfMeasure(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingPriceUnitOfMeasure.new", 
    "    UnderlyingPriceUnitOfMeasure.new()\n"
    "    UnderlyingPriceUnitOfMeasure.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPriceUnitOfMeasure(FIX::UnderlyingPriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class SwigClassMarketUpdateAction;

SWIGINTERN VALUE
_wrap_new_MarketUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarketUpdateAction";
  FIX::MarketUpdateAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarketUpdateAction *)new FIX::MarketUpdateAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarketUpdateAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarketUpdateAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarketUpdateAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarketUpdateAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketUpdateAction";
  FIX::MarketUpdateAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MarketUpdateAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MarketUpdateAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MarketUpdateAction *)new FIX::MarketUpdateAction((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarketUpdateAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarketUpdateAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketUpdateAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarketUpdateAction.new", 
    "    MarketUpdateAction.new()\n"
    "    MarketUpdateAction.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketUpdateAction(FIX::MarketUpdateAction *arg1) {
    delete arg1;
}

swig_class SwigClassCollAsgnRejectReason;

SWIGINTERN VALUE
_wrap_new_CollAsgnRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRejectReason";
  FIX::CollAsgnRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAsgnRejectReason *)new FIX::CollAsgnRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAsgnRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAsgnRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAsgnRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRejectReason";
  FIX::CollAsgnRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollAsgnRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollAsgnRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollAsgnRejectReason *)new FIX::CollAsgnRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAsgnRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAsgnRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAsgnRejectReason.new", 
    "    CollAsgnRejectReason.new()\n"
    "    CollAsgnRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnRejectReason(FIX::CollAsgnRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassPeggedRefPrice;

SWIGINTERN VALUE
_wrap_new_PeggedRefPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PeggedRefPrice";
  FIX::PeggedRefPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PeggedRefPrice *)new FIX::PeggedRefPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PeggedRefPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PeggedRefPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PeggedRefPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PeggedRefPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PeggedRefPrice";
  FIX::PeggedRefPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::PeggedRefPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::PeggedRefPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::PeggedRefPrice *)new FIX::PeggedRefPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PeggedRefPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PeggedRefPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PeggedRefPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PeggedRefPrice.new", 
    "    PeggedRefPrice.new()\n"
    "    PeggedRefPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PeggedRefPrice(FIX::PeggedRefPrice *arg1) {
    delete arg1;
}

swig_class SwigClassIndividualAllocType;

SWIGINTERN VALUE
_wrap_new_IndividualAllocType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocType";
  FIX::IndividualAllocType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IndividualAllocType *)new FIX::IndividualAllocType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IndividualAllocType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IndividualAllocType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IndividualAllocType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IndividualAllocType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocType";
  FIX::IndividualAllocType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::IndividualAllocType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::IndividualAllocType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::IndividualAllocType *)new FIX::IndividualAllocType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IndividualAllocType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IndividualAllocType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndividualAllocType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IndividualAllocType.new", 
    "    IndividualAllocType.new()\n"
    "    IndividualAllocType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IndividualAllocType(FIX::IndividualAllocType *arg1) {
    delete arg1;
}

swig_class SwigClassEndCash;

SWIGINTERN VALUE
_wrap_new_EndCash__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndCash";
  FIX::EndCash *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndCash *)new FIX::EndCash();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndCash_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndCash_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndCash);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndCash__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndCash";
  FIX::EndCash *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::EndCash", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::EndCash", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::EndCash *)new FIX::EndCash((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndCash(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndCash__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndCash__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndCash.new", 
    "    EndCash.new()\n"
    "    EndCash.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndCash(FIX::EndCash *arg1) {
    delete arg1;
}

swig_class SwigClassEventText;

SWIGINTERN VALUE
_wrap_new_EventText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EventText";
  FIX::EventText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EventText *)new FIX::EventText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EventText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EventText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EventText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EventText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventText";
  FIX::EventText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::EventText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::EventText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::EventText *)new FIX::EventText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EventText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EventText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EventText.new", 
    "    EventText.new()\n"
    "    EventText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EventText(FIX::EventText *arg1) {
    delete arg1;
}

swig_class SwigClassExDate;

SWIGINTERN VALUE
_wrap_new_ExDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExDate";
  FIX::ExDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExDate *)new FIX::ExDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDate";
  FIX::ExDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::ExDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::ExDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::ExDate *)new FIX::ExDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExDate.new", 
    "    ExDate.new()\n"
    "    ExDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExDate(FIX::ExDate *arg1) {
    delete arg1;
}

swig_class SwigClassNestedPartyIDSource;

SWIGINTERN VALUE
_wrap_new_NestedPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyIDSource";
  FIX::NestedPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedPartyIDSource *)new FIX::NestedPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyIDSource";
  FIX::NestedPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::NestedPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::NestedPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::NestedPartyIDSource *)new FIX::NestedPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedPartyIDSource.new", 
    "    NestedPartyIDSource.new()\n"
    "    NestedPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartyIDSource(FIX::NestedPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassGTBookingInst;

SWIGINTERN VALUE
_wrap_new_GTBookingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::GTBookingInst";
  FIX::GTBookingInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::GTBookingInst *)new FIX::GTBookingInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_GTBookingInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_GTBookingInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__GTBookingInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_GTBookingInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GTBookingInst";
  FIX::GTBookingInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::GTBookingInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::GTBookingInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::GTBookingInst *)new FIX::GTBookingInst((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GTBookingInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_GTBookingInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GTBookingInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GTBookingInst.new", 
    "    GTBookingInst.new()\n"
    "    GTBookingInst.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_GTBookingInst(FIX::GTBookingInst *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeValuationMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeValuationMethod";
  FIX::DerivativeValuationMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeValuationMethod *)new FIX::DerivativeValuationMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeValuationMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeValuationMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeValuationMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeValuationMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeValuationMethod";
  FIX::DerivativeValuationMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeValuationMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeValuationMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeValuationMethod *)new FIX::DerivativeValuationMethod((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeValuationMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeValuationMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeValuationMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeValuationMethod.new", 
    "    DerivativeValuationMethod.new()\n"
    "    DerivativeValuationMethod.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeValuationMethod(FIX::DerivativeValuationMethod *arg1) {
    delete arg1;
}

swig_class SwigClassNumberOfOrders;

SWIGINTERN VALUE
_wrap_new_NumberOfOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NumberOfOrders";
  FIX::NumberOfOrders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NumberOfOrders *)new FIX::NumberOfOrders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NumberOfOrders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NumberOfOrders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NumberOfOrders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NumberOfOrders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumberOfOrders";
  FIX::NumberOfOrders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NumberOfOrders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NumberOfOrders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NumberOfOrders *)new FIX::NumberOfOrders((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NumberOfOrders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NumberOfOrders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumberOfOrders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NumberOfOrders.new", 
    "    NumberOfOrders.new()\n"
    "    NumberOfOrders.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NumberOfOrders(FIX::NumberOfOrders *arg1) {
    delete arg1;
}

swig_class SwigClassTrdRepPartyRole;

SWIGINTERN VALUE
_wrap_new_TrdRepPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdRepPartyRole";
  FIX::TrdRepPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdRepPartyRole *)new FIX::TrdRepPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdRepPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdRepPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdRepPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdRepPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRepPartyRole";
  FIX::TrdRepPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TrdRepPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TrdRepPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TrdRepPartyRole *)new FIX::TrdRepPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdRepPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdRepPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRepPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdRepPartyRole.new", 
    "    TrdRepPartyRole.new()\n"
    "    TrdRepPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRepPartyRole(FIX::TrdRepPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerPrice;

SWIGINTERN VALUE
_wrap_new_TriggerPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerPrice";
  FIX::TriggerPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerPrice *)new FIX::TriggerPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPrice";
  FIX::TriggerPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::TriggerPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::TriggerPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::TriggerPrice *)new FIX::TriggerPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerPrice.new", 
    "    TriggerPrice.new()\n"
    "    TriggerPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPrice(FIX::TriggerPrice *arg1) {
    delete arg1;
}

swig_class SwigClassMDReportID;

SWIGINTERN VALUE
_wrap_new_MDReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDReportID";
  FIX::MDReportID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDReportID *)new FIX::MDReportID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDReportID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDReportID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDReportID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDReportID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReportID";
  FIX::MDReportID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDReportID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDReportID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDReportID *)new FIX::MDReportID((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDReportID.new", 
    "    MDReportID.new()\n"
    "    MDReportID.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDReportID(FIX::MDReportID *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryAllocID;

SWIGINTERN VALUE
_wrap_new_SecondaryAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryAllocID";
  FIX::SecondaryAllocID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryAllocID *)new FIX::SecondaryAllocID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryAllocID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryAllocID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryAllocID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryAllocID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryAllocID";
  FIX::SecondaryAllocID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryAllocID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryAllocID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryAllocID *)new FIX::SecondaryAllocID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryAllocID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryAllocID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryAllocID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryAllocID.new", 
    "    SecondaryAllocID.new()\n"
    "    SecondaryAllocID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryAllocID(FIX::SecondaryAllocID *arg1) {
    delete arg1;
}

swig_class SwigClassLeavesQty;

SWIGINTERN VALUE
_wrap_new_LeavesQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LeavesQty";
  FIX::LeavesQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LeavesQty *)new FIX::LeavesQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LeavesQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LeavesQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LeavesQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LeavesQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LeavesQty";
  FIX::LeavesQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LeavesQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LeavesQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LeavesQty *)new FIX::LeavesQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LeavesQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LeavesQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LeavesQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LeavesQty.new", 
    "    LeavesQty.new()\n"
    "    LeavesQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LeavesQty(FIX::LeavesQty *arg1) {
    delete arg1;
}

swig_class SwigClassCardStartDate;

SWIGINTERN VALUE
_wrap_new_CardStartDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CardStartDate";
  FIX::CardStartDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CardStartDate *)new FIX::CardStartDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CardStartDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CardStartDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CardStartDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CardStartDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardStartDate";
  FIX::CardStartDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::CardStartDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::CardStartDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::CardStartDate *)new FIX::CardStartDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CardStartDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CardStartDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardStartDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CardStartDate.new", 
    "    CardStartDate.new()\n"
    "    CardStartDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CardStartDate(FIX::CardStartDate *arg1) {
    delete arg1;
}

swig_class SwigClassLegCoveredOrUncovered;

SWIGINTERN VALUE
_wrap_new_LegCoveredOrUncovered__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCoveredOrUncovered";
  FIX::LegCoveredOrUncovered *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCoveredOrUncovered *)new FIX::LegCoveredOrUncovered();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCoveredOrUncovered_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCoveredOrUncovered_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCoveredOrUncovered);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCoveredOrUncovered__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCoveredOrUncovered";
  FIX::LegCoveredOrUncovered *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegCoveredOrUncovered", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegCoveredOrUncovered", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegCoveredOrUncovered *)new FIX::LegCoveredOrUncovered((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCoveredOrUncovered(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCoveredOrUncovered__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCoveredOrUncovered__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCoveredOrUncovered.new", 
    "    LegCoveredOrUncovered.new()\n"
    "    LegCoveredOrUncovered.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCoveredOrUncovered(FIX::LegCoveredOrUncovered *arg1) {
    delete arg1;
}

swig_class SwigClassPutOrCall;

SWIGINTERN VALUE
_wrap_new_PutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PutOrCall";
  FIX::PutOrCall *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PutOrCall *)new FIX::PutOrCall();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PutOrCall_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PutOrCall_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PutOrCall);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PutOrCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PutOrCall";
  FIX::PutOrCall *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PutOrCall", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PutOrCall", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PutOrCall *)new FIX::PutOrCall((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PutOrCall.new", 
    "    PutOrCall.new()\n"
    "    PutOrCall.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PutOrCall(FIX::PutOrCall *arg1) {
    delete arg1;
}

swig_class SwigClassMatchAlgorithm;

SWIGINTERN VALUE
_wrap_new_MatchAlgorithm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MatchAlgorithm";
  FIX::MatchAlgorithm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MatchAlgorithm *)new FIX::MatchAlgorithm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MatchAlgorithm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MatchAlgorithm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MatchAlgorithm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MatchAlgorithm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchAlgorithm";
  FIX::MatchAlgorithm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MatchAlgorithm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MatchAlgorithm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MatchAlgorithm *)new FIX::MatchAlgorithm((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MatchAlgorithm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MatchAlgorithm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchAlgorithm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MatchAlgorithm.new", 
    "    MatchAlgorithm.new()\n"
    "    MatchAlgorithm.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchAlgorithm(FIX::MatchAlgorithm *arg1) {
    delete arg1;
}

swig_class SwigClassCalculatedCcyLastQty;

SWIGINTERN VALUE
_wrap_new_CalculatedCcyLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CalculatedCcyLastQty";
  FIX::CalculatedCcyLastQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CalculatedCcyLastQty *)new FIX::CalculatedCcyLastQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CalculatedCcyLastQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CalculatedCcyLastQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CalculatedCcyLastQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CalculatedCcyLastQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CalculatedCcyLastQty";
  FIX::CalculatedCcyLastQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::CalculatedCcyLastQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::CalculatedCcyLastQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::CalculatedCcyLastQty *)new FIX::CalculatedCcyLastQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CalculatedCcyLastQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CalculatedCcyLastQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalculatedCcyLastQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CalculatedCcyLastQty.new", 
    "    CalculatedCcyLastQty.new()\n"
    "    CalculatedCcyLastQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CalculatedCcyLastQty(FIX::CalculatedCcyLastQty *arg1) {
    delete arg1;
}

swig_class SwigClassFundRenewWaiv;

SWIGINTERN VALUE
_wrap_new_FundRenewWaiv__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FundRenewWaiv";
  FIX::FundRenewWaiv *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FundRenewWaiv *)new FIX::FundRenewWaiv();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FundRenewWaiv_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FundRenewWaiv_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FundRenewWaiv);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FundRenewWaiv__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FundRenewWaiv";
  FIX::FundRenewWaiv *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::FundRenewWaiv", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::FundRenewWaiv", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::FundRenewWaiv *)new FIX::FundRenewWaiv((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FundRenewWaiv(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FundRenewWaiv__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FundRenewWaiv__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FundRenewWaiv.new", 
    "    FundRenewWaiv.new()\n"
    "    FundRenewWaiv.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FundRenewWaiv(FIX::FundRenewWaiv *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySettlAgentName;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentName";
  FIX::SecuritySettlAgentName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySettlAgentName *)new FIX::SecuritySettlAgentName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySettlAgentName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySettlAgentName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySettlAgentName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentName";
  FIX::SecuritySettlAgentName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySettlAgentName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySettlAgentName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySettlAgentName *)new FIX::SecuritySettlAgentName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySettlAgentName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySettlAgentName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySettlAgentName.new", 
    "    SecuritySettlAgentName.new()\n"
    "    SecuritySettlAgentName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentName(FIX::SecuritySettlAgentName *arg1) {
    delete arg1;
}

swig_class SwigClassBidDescriptor;

SWIGINTERN VALUE
_wrap_new_BidDescriptor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptor";
  FIX::BidDescriptor *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidDescriptor *)new FIX::BidDescriptor();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidDescriptor_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidDescriptor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidDescriptor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidDescriptor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptor";
  FIX::BidDescriptor *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BidDescriptor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BidDescriptor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BidDescriptor *)new FIX::BidDescriptor((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidDescriptor(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidDescriptor__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidDescriptor__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidDescriptor.new", 
    "    BidDescriptor.new()\n"
    "    BidDescriptor.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidDescriptor(FIX::BidDescriptor *arg1) {
    delete arg1;
}

swig_class SwigClassMDStreamID;

SWIGINTERN VALUE
_wrap_new_MDStreamID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDStreamID";
  FIX::MDStreamID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDStreamID *)new FIX::MDStreamID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDStreamID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDStreamID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDStreamID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDStreamID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDStreamID";
  FIX::MDStreamID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDStreamID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDStreamID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDStreamID *)new FIX::MDStreamID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDStreamID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDStreamID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDStreamID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDStreamID.new", 
    "    MDStreamID.new()\n"
    "    MDStreamID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDStreamID(FIX::MDStreamID *arg1) {
    delete arg1;
}

swig_class SwigClassNoAsgnReqs;

SWIGINTERN VALUE
_wrap_new_NoAsgnReqs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoAsgnReqs";
  FIX::NoAsgnReqs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoAsgnReqs *)new FIX::NoAsgnReqs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoAsgnReqs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoAsgnReqs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoAsgnReqs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoAsgnReqs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAsgnReqs";
  FIX::NoAsgnReqs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoAsgnReqs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoAsgnReqs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoAsgnReqs *)new FIX::NoAsgnReqs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoAsgnReqs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoAsgnReqs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAsgnReqs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoAsgnReqs.new", 
    "    NoAsgnReqs.new()\n"
    "    NoAsgnReqs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAsgnReqs(FIX::NoAsgnReqs *arg1) {
    delete arg1;
}

swig_class SwigClassNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_NotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NotionalPercentageOutstanding";
  FIX::NotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NotionalPercentageOutstanding *)new FIX::NotionalPercentageOutstanding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NotionalPercentageOutstanding_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NotionalPercentageOutstanding_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NotionalPercentageOutstanding);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NotionalPercentageOutstanding__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotionalPercentageOutstanding";
  FIX::NotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::NotionalPercentageOutstanding", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::NotionalPercentageOutstanding", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::NotionalPercentageOutstanding *)new FIX::NotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NotionalPercentageOutstanding(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NotionalPercentageOutstanding__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotionalPercentageOutstanding__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NotionalPercentageOutstanding.new", 
    "    NotionalPercentageOutstanding.new()\n"
    "    NotionalPercentageOutstanding.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NotionalPercentageOutstanding(FIX::NotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class SwigClassNoSettlInst;

SWIGINTERN VALUE
_wrap_new_NoSettlInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSettlInst";
  FIX::NoSettlInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSettlInst *)new FIX::NoSettlInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSettlInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSettlInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSettlInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSettlInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlInst";
  FIX::NoSettlInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSettlInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSettlInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSettlInst *)new FIX::NoSettlInst((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSettlInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSettlInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSettlInst.new", 
    "    NoSettlInst.new()\n"
    "    NoSettlInst.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlInst(FIX::NoSettlInst *arg1) {
    delete arg1;
}

swig_class SwigClassSettlInstMsgID;

SWIGINTERN VALUE
_wrap_new_SettlInstMsgID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMsgID";
  FIX::SettlInstMsgID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlInstMsgID *)new FIX::SettlInstMsgID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlInstMsgID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlInstMsgID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlInstMsgID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlInstMsgID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMsgID";
  FIX::SettlInstMsgID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlInstMsgID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlInstMsgID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlInstMsgID *)new FIX::SettlInstMsgID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlInstMsgID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlInstMsgID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstMsgID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlInstMsgID.new", 
    "    SettlInstMsgID.new()\n"
    "    SettlInstMsgID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstMsgID(FIX::SettlInstMsgID *arg1) {
    delete arg1;
}

swig_class SwigClassForexReq;

SWIGINTERN VALUE
_wrap_new_ForexReq__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ForexReq";
  FIX::ForexReq *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ForexReq *)new FIX::ForexReq();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ForexReq_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ForexReq_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ForexReq);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ForexReq__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ForexReq";
  FIX::ForexReq *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ForexReq", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ForexReq", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ForexReq *)new FIX::ForexReq((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ForexReq(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ForexReq__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ForexReq__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ForexReq.new", 
    "    ForexReq.new()\n"
    "    ForexReq.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ForexReq(FIX::ForexReq *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesReqID;

SWIGINTERN VALUE
_wrap_new_TradSesReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesReqID";
  FIX::TradSesReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesReqID *)new FIX::TradSesReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesReqID";
  FIX::TradSesReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradSesReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradSesReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradSesReqID *)new FIX::TradSesReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesReqID.new", 
    "    TradSesReqID.new()\n"
    "    TradSesReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesReqID(FIX::TradSesReqID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegStrikePrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegStrikePrice";
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegStrikePrice *)new FIX::UnderlyingLegStrikePrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegStrikePrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegStrikePrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegStrikePrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegStrikePrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegStrikePrice";
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::UnderlyingLegStrikePrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::UnderlyingLegStrikePrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::UnderlyingLegStrikePrice *)new FIX::UnderlyingLegStrikePrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegStrikePrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegStrikePrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegStrikePrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegStrikePrice.new", 
    "    UnderlyingLegStrikePrice.new()\n"
    "    UnderlyingLegStrikePrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegStrikePrice(FIX::UnderlyingLegStrikePrice *arg1) {
    delete arg1;
}

swig_class SwigClassTickRuleType;

SWIGINTERN VALUE
_wrap_new_TickRuleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TickRuleType";
  FIX::TickRuleType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TickRuleType *)new FIX::TickRuleType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TickRuleType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TickRuleType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TickRuleType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TickRuleType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickRuleType";
  FIX::TickRuleType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TickRuleType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TickRuleType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TickRuleType *)new FIX::TickRuleType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TickRuleType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TickRuleType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TickRuleType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TickRuleType.new", 
    "    TickRuleType.new()\n"
    "    TickRuleType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TickRuleType(FIX::TickRuleType *arg1) {
    delete arg1;
}

swig_class SwigClassInstrmtAssignmentMethod;

SWIGINTERN VALUE
_wrap_new_InstrmtAssignmentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrmtAssignmentMethod";
  FIX::InstrmtAssignmentMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrmtAssignmentMethod *)new FIX::InstrmtAssignmentMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrmtAssignmentMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrmtAssignmentMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrmtAssignmentMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrmtAssignmentMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrmtAssignmentMethod";
  FIX::InstrmtAssignmentMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::InstrmtAssignmentMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::InstrmtAssignmentMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::InstrmtAssignmentMethod *)new FIX::InstrmtAssignmentMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrmtAssignmentMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrmtAssignmentMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrmtAssignmentMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrmtAssignmentMethod.new", 
    "    InstrmtAssignmentMethod.new()\n"
    "    InstrmtAssignmentMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrmtAssignmentMethod(FIX::InstrmtAssignmentMethod *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionOffsetType;

SWIGINTERN VALUE
_wrap_new_DiscretionOffsetType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetType";
  FIX::DiscretionOffsetType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionOffsetType *)new FIX::DiscretionOffsetType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionOffsetType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionOffsetType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionOffsetType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionOffsetType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetType";
  FIX::DiscretionOffsetType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DiscretionOffsetType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DiscretionOffsetType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DiscretionOffsetType *)new FIX::DiscretionOffsetType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionOffsetType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionOffsetType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionOffsetType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionOffsetType.new", 
    "    DiscretionOffsetType.new()\n"
    "    DiscretionOffsetType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionOffsetType(FIX::DiscretionOffsetType *arg1) {
    delete arg1;
}

swig_class SwigClassConfirmTransType;

SWIGINTERN VALUE
_wrap_new_ConfirmTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ConfirmTransType";
  FIX::ConfirmTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ConfirmTransType *)new FIX::ConfirmTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConfirmTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConfirmTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ConfirmTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConfirmTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmTransType";
  FIX::ConfirmTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ConfirmTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ConfirmTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ConfirmTransType *)new FIX::ConfirmTransType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConfirmTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConfirmTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConfirmTransType.new", 
    "    ConfirmTransType.new()\n"
    "    ConfirmTransType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmTransType(FIX::ConfirmTransType *arg1) {
    delete arg1;
}

swig_class SwigClassTotalTakedown;

SWIGINTERN VALUE
_wrap_new_TotalTakedown__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalTakedown";
  FIX::TotalTakedown *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalTakedown *)new FIX::TotalTakedown();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalTakedown_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalTakedown_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalTakedown);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalTakedown__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalTakedown";
  FIX::TotalTakedown *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::TotalTakedown", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::TotalTakedown", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::TotalTakedown *)new FIX::TotalTakedown((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalTakedown(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalTakedown__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalTakedown__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalTakedown.new", 
    "    TotalTakedown.new()\n"
    "    TotalTakedown.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalTakedown(FIX::TotalTakedown *arg1) {
    delete arg1;
}

swig_class SwigClassResponseDestination;

SWIGINTERN VALUE
_wrap_new_ResponseDestination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ResponseDestination";
  FIX::ResponseDestination *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ResponseDestination *)new FIX::ResponseDestination();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ResponseDestination_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ResponseDestination_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ResponseDestination);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ResponseDestination__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResponseDestination";
  FIX::ResponseDestination *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ResponseDestination", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ResponseDestination", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ResponseDestination *)new FIX::ResponseDestination((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ResponseDestination(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ResponseDestination__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResponseDestination__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ResponseDestination.new", 
    "    ResponseDestination.new()\n"
    "    ResponseDestination.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ResponseDestination(FIX::ResponseDestination *arg1) {
    delete arg1;
}

swig_class SwigClassMDSecSizeType;

SWIGINTERN VALUE
_wrap_new_MDSecSizeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDSecSizeType";
  FIX::MDSecSizeType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDSecSizeType *)new FIX::MDSecSizeType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDSecSizeType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDSecSizeType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDSecSizeType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDSecSizeType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSecSizeType";
  FIX::MDSecSizeType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MDSecSizeType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MDSecSizeType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MDSecSizeType *)new FIX::MDSecSizeType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDSecSizeType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDSecSizeType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDSecSizeType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDSecSizeType.new", 
    "    MDSecSizeType.new()\n"
    "    MDSecSizeType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDSecSizeType(FIX::MDSecSizeType *arg1) {
    delete arg1;
}

swig_class SwigClassInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_InstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubIDType";
  FIX::InstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrumentPartySubIDType *)new FIX::InstrumentPartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrumentPartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrumentPartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrumentPartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrumentPartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubIDType";
  FIX::InstrumentPartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::InstrumentPartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::InstrumentPartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::InstrumentPartySubIDType *)new FIX::InstrumentPartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrumentPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrumentPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrumentPartySubIDType.new", 
    "    InstrumentPartySubIDType.new()\n"
    "    InstrumentPartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartySubIDType(FIX::InstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassLegTimeUnit;

SWIGINTERN VALUE
_wrap_new_LegTimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegTimeUnit";
  FIX::LegTimeUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegTimeUnit *)new FIX::LegTimeUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegTimeUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegTimeUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegTimeUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegTimeUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegTimeUnit";
  FIX::LegTimeUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegTimeUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegTimeUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegTimeUnit *)new FIX::LegTimeUnit((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegTimeUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegTimeUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegTimeUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegTimeUnit.new", 
    "    LegTimeUnit.new()\n"
    "    LegTimeUnit.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegTimeUnit(FIX::LegTimeUnit *arg1) {
    delete arg1;
}

swig_class SwigClassTransferReason;

SWIGINTERN VALUE
_wrap_new_TransferReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TransferReason";
  FIX::TransferReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TransferReason *)new FIX::TransferReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TransferReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TransferReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TransferReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TransferReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransferReason";
  FIX::TransferReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TransferReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TransferReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TransferReason *)new FIX::TransferReason((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TransferReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TransferReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransferReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TransferReason.new", 
    "    TransferReason.new()\n"
    "    TransferReason.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TransferReason(FIX::TransferReason *arg1) {
    delete arg1;
}

swig_class SwigClassApplQueueMax;

SWIGINTERN VALUE
_wrap_new_ApplQueueMax__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueMax";
  FIX::ApplQueueMax *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplQueueMax *)new FIX::ApplQueueMax();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplQueueMax_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplQueueMax_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplQueueMax);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplQueueMax__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueMax";
  FIX::ApplQueueMax *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplQueueMax", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplQueueMax", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplQueueMax *)new FIX::ApplQueueMax((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplQueueMax(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplQueueMax__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueMax__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplQueueMax.new", 
    "    ApplQueueMax.new()\n"
    "    ApplQueueMax.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueMax(FIX::ApplQueueMax *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionOffsetValue;

SWIGINTERN VALUE
_wrap_new_DiscretionOffsetValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetValue";
  FIX::DiscretionOffsetValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionOffsetValue *)new FIX::DiscretionOffsetValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionOffsetValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionOffsetValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionOffsetValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionOffsetValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetValue";
  FIX::DiscretionOffsetValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::DiscretionOffsetValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::DiscretionOffsetValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::DiscretionOffsetValue *)new FIX::DiscretionOffsetValue((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionOffsetValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionOffsetValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionOffsetValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionOffsetValue.new", 
    "    DiscretionOffsetValue.new()\n"
    "    DiscretionOffsetValue.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionOffsetValue(FIX::DiscretionOffsetValue *arg1) {
    delete arg1;
}

swig_class SwigClassBookingRefID;

SWIGINTERN VALUE
_wrap_new_BookingRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BookingRefID";
  FIX::BookingRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BookingRefID *)new FIX::BookingRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BookingRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BookingRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BookingRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BookingRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingRefID";
  FIX::BookingRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BookingRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BookingRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BookingRefID *)new FIX::BookingRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BookingRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BookingRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BookingRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BookingRefID.new", 
    "    BookingRefID.new()\n"
    "    BookingRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BookingRefID(FIX::BookingRefID *arg1) {
    delete arg1;
}

swig_class SwigClassLegBidPx;

SWIGINTERN VALUE
_wrap_new_LegBidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBidPx";
  FIX::LegBidPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBidPx *)new FIX::LegBidPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBidPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBidPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBidPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBidPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBidPx";
  FIX::LegBidPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LegBidPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LegBidPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LegBidPx *)new FIX::LegBidPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBidPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBidPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBidPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBidPx.new", 
    "    LegBidPx.new()\n"
    "    LegBidPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBidPx(FIX::LegBidPx *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesEvent;

SWIGINTERN VALUE
_wrap_new_TradSesEvent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesEvent";
  FIX::TradSesEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesEvent *)new FIX::TradSesEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesEvent_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesEvent_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesEvent);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesEvent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEvent";
  FIX::TradSesEvent *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradSesEvent", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradSesEvent", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradSesEvent *)new FIX::TradSesEvent((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesEvent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesEvent__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesEvent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesEvent.new", 
    "    TradSesEvent.new()\n"
    "    TradSesEvent.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesEvent(FIX::TradSesEvent *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeProduct;

SWIGINTERN VALUE
_wrap_new_DerivativeProduct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProduct";
  FIX::DerivativeProduct *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeProduct *)new FIX::DerivativeProduct();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeProduct_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeProduct_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeProduct);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeProduct__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProduct";
  FIX::DerivativeProduct *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeProduct", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeProduct", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeProduct *)new FIX::DerivativeProduct((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeProduct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeProduct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeProduct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeProduct.new", 
    "    DerivativeProduct.new()\n"
    "    DerivativeProduct.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeProduct(FIX::DerivativeProduct *arg1) {
    delete arg1;
}

swig_class SwigClassRootPartyRole;

SWIGINTERN VALUE
_wrap_new_RootPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RootPartyRole";
  FIX::RootPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RootPartyRole *)new FIX::RootPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RootPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RootPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RootPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RootPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyRole";
  FIX::RootPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RootPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RootPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RootPartyRole *)new FIX::RootPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RootPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RootPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RootPartyRole.new", 
    "    RootPartyRole.new()\n"
    "    RootPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartyRole(FIX::RootPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassDlvyInstType;

SWIGINTERN VALUE
_wrap_new_DlvyInstType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DlvyInstType";
  FIX::DlvyInstType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DlvyInstType *)new FIX::DlvyInstType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DlvyInstType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DlvyInstType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DlvyInstType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DlvyInstType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DlvyInstType";
  FIX::DlvyInstType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DlvyInstType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DlvyInstType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DlvyInstType *)new FIX::DlvyInstType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DlvyInstType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DlvyInstType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DlvyInstType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DlvyInstType.new", 
    "    DlvyInstType.new()\n"
    "    DlvyInstType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DlvyInstType(FIX::DlvyInstType *arg1) {
    delete arg1;
}

swig_class SwigClassNoLinesOfText;

SWIGINTERN VALUE
_wrap_new_NoLinesOfText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoLinesOfText";
  FIX::NoLinesOfText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoLinesOfText *)new FIX::NoLinesOfText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoLinesOfText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoLinesOfText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoLinesOfText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoLinesOfText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLinesOfText";
  FIX::NoLinesOfText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoLinesOfText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoLinesOfText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoLinesOfText *)new FIX::NoLinesOfText((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoLinesOfText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoLinesOfText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLinesOfText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoLinesOfText.new", 
    "    NoLinesOfText.new()\n"
    "    NoLinesOfText.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLinesOfText(FIX::NoLinesOfText *arg1) {
    delete arg1;
}

swig_class SwigClassPosReqID;

SWIGINTERN VALUE
_wrap_new_PosReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosReqID";
  FIX::PosReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosReqID *)new FIX::PosReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqID";
  FIX::PosReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PosReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PosReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PosReqID *)new FIX::PosReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosReqID.new", 
    "    PosReqID.new()\n"
    "    PosReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqID(FIX::PosReqID *arg1) {
    delete arg1;
}

swig_class SwigClassLegSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_LegSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltIDSource";
  FIX::LegSecurityAltIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSecurityAltIDSource *)new FIX::LegSecurityAltIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSecurityAltIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSecurityAltIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSecurityAltIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSecurityAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltIDSource";
  FIX::LegSecurityAltIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSecurityAltIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSecurityAltIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSecurityAltIDSource *)new FIX::LegSecurityAltIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSecurityAltIDSource.new", 
    "    LegSecurityAltIDSource.new()\n"
    "    LegSecurityAltIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityAltIDSource(FIX::LegSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedSubject;

SWIGINTERN VALUE
_wrap_new_EncodedSubject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubject";
  FIX::EncodedSubject *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedSubject *)new FIX::EncodedSubject();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedSubject_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedSubject_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedSubject);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedSubject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubject";
  FIX::EncodedSubject *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedSubject", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedSubject", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedSubject *)new FIX::EncodedSubject((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSubject(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSubject__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSubject__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedSubject.new", 
    "    EncodedSubject.new()\n"
    "    EncodedSubject.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSubject(FIX::EncodedSubject *arg1) {
    delete arg1;
}

swig_class SwigClassContraBroker;

SWIGINTERN VALUE
_wrap_new_ContraBroker__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContraBroker";
  FIX::ContraBroker *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContraBroker *)new FIX::ContraBroker();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContraBroker_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContraBroker_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContraBroker);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContraBroker__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraBroker";
  FIX::ContraBroker *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ContraBroker", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ContraBroker", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ContraBroker *)new FIX::ContraBroker((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContraBroker(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContraBroker__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraBroker__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContraBroker.new", 
    "    ContraBroker.new()\n"
    "    ContraBroker.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraBroker(FIX::ContraBroker *arg1) {
    delete arg1;
}

swig_class SwigClassTradeCondition;

SWIGINTERN VALUE
_wrap_new_TradeCondition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeCondition";
  FIX::TradeCondition *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeCondition *)new FIX::TradeCondition();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeCondition_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeCondition_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeCondition);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeCondition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeCondition";
  FIX::TradeCondition *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLESTRINGVALUE const &","FIX::TradeCondition", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLESTRINGVALUE const &","FIX::TradeCondition", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  result = (FIX::TradeCondition *)new FIX::TradeCondition((FIX::MULTIPLESTRINGVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeCondition(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeCondition__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeCondition__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeCondition.new", 
    "    TradeCondition.new()\n"
    "    TradeCondition.new(FIX::MULTIPLESTRINGVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeCondition(FIX::TradeCondition *arg1) {
    delete arg1;
}

swig_class SwigClassPartyID;

SWIGINTERN VALUE
_wrap_new_PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PartyID";
  FIX::PartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PartyID *)new FIX::PartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyID";
  FIX::PartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PartyID *)new FIX::PartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PartyID.new", 
    "    PartyID.new()\n"
    "    PartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyID(FIX::PartyID *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryID;

SWIGINTERN VALUE
_wrap_new_MDEntryID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryID";
  FIX::MDEntryID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryID *)new FIX::MDEntryID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryID";
  FIX::MDEntryID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDEntryID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDEntryID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDEntryID *)new FIX::MDEntryID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryID.new", 
    "    MDEntryID.new()\n"
    "    MDEntryID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryID(FIX::MDEntryID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityExchange;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityExchange";
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityExchange *)new FIX::UnderlyingLegSecurityExchange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityExchange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityExchange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityExchange";
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityExchange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityExchange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityExchange *)new FIX::UnderlyingLegSecurityExchange((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityExchange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityExchange.new", 
    "    UnderlyingLegSecurityExchange.new()\n"
    "    UnderlyingLegSecurityExchange.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityExchange(FIX::UnderlyingLegSecurityExchange *arg1) {
    delete arg1;
}

swig_class SwigClassPriceLimitType;

SWIGINTERN VALUE
_wrap_new_PriceLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceLimitType";
  FIX::PriceLimitType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceLimitType *)new FIX::PriceLimitType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceLimitType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceLimitType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceLimitType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceLimitType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceLimitType";
  FIX::PriceLimitType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PriceLimitType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PriceLimitType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PriceLimitType *)new FIX::PriceLimitType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceLimitType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceLimitType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceLimitType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceLimitType.new", 
    "    PriceLimitType.new()\n"
    "    PriceLimitType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceLimitType(FIX::PriceLimitType *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_TriggerSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityIDSource";
  FIX::TriggerSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerSecurityIDSource *)new FIX::TriggerSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityIDSource";
  FIX::TriggerSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TriggerSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TriggerSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TriggerSecurityIDSource *)new FIX::TriggerSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerSecurityIDSource.new", 
    "    TriggerSecurityIDSource.new()\n"
    "    TriggerSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSecurityIDSource(FIX::TriggerSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassNoUndlyInstrumentPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentPartySubIDs";
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUndlyInstrumentPartySubIDs *)new FIX::NoUndlyInstrumentPartySubIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUndlyInstrumentPartySubIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUndlyInstrumentPartySubIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentPartySubIDs";
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUndlyInstrumentPartySubIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUndlyInstrumentPartySubIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUndlyInstrumentPartySubIDs *)new FIX::NoUndlyInstrumentPartySubIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUndlyInstrumentPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUndlyInstrumentPartySubIDs.new", 
    "    NoUndlyInstrumentPartySubIDs.new()\n"
    "    NoUndlyInstrumentPartySubIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUndlyInstrumentPartySubIDs(FIX::NoUndlyInstrumentPartySubIDs *arg1) {
    delete arg1;
}

swig_class SwigClassClientBidID;

SWIGINTERN VALUE
_wrap_new_ClientBidID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ClientBidID";
  FIX::ClientBidID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ClientBidID *)new FIX::ClientBidID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ClientBidID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ClientBidID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ClientBidID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ClientBidID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClientBidID";
  FIX::ClientBidID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ClientBidID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ClientBidID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ClientBidID *)new FIX::ClientBidID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ClientBidID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ClientBidID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClientBidID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ClientBidID.new", 
    "    ClientBidID.new()\n"
    "    ClientBidID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ClientBidID(FIX::ClientBidID *arg1) {
    delete arg1;
}

swig_class SwigClassNetChgPrevDay;

SWIGINTERN VALUE
_wrap_new_NetChgPrevDay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetChgPrevDay";
  FIX::NetChgPrevDay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetChgPrevDay *)new FIX::NetChgPrevDay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetChgPrevDay_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetChgPrevDay_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetChgPrevDay);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetChgPrevDay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetChgPrevDay";
  FIX::NetChgPrevDay *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::NetChgPrevDay", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::NetChgPrevDay", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::NetChgPrevDay *)new FIX::NetChgPrevDay((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetChgPrevDay(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetChgPrevDay__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetChgPrevDay__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetChgPrevDay.new", 
    "    NetChgPrevDay.new()\n"
    "    NetChgPrevDay.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetChgPrevDay(FIX::NetChgPrevDay *arg1) {
    delete arg1;
}

swig_class SwigClassDefaultApplVerID;

SWIGINTERN VALUE
_wrap_new_DefaultApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplVerID";
  FIX::DefaultApplVerID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DefaultApplVerID *)new FIX::DefaultApplVerID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DefaultApplVerID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DefaultApplVerID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DefaultApplVerID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DefaultApplVerID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplVerID";
  FIX::DefaultApplVerID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DefaultApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DefaultApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DefaultApplVerID *)new FIX::DefaultApplVerID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefaultApplVerID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DefaultApplVerID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultApplVerID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DefaultApplVerID.new", 
    "    DefaultApplVerID.new()\n"
    "    DefaultApplVerID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultApplVerID(FIX::DefaultApplVerID *arg1) {
    delete arg1;
}

swig_class SwigClassIOIID;

SWIGINTERN VALUE
_wrap_new_IOIID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIID";
  FIX::IOIID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIID *)new FIX::IOIID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIID";
  FIX::IOIID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::IOIID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::IOIID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::IOIID *)new FIX::IOIID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIID.new", 
    "    IOIID.new()\n"
    "    IOIID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIID(FIX::IOIID *arg1) {
    delete arg1;
}

swig_class SwigClassSpreadToBenchmark;

SWIGINTERN VALUE
_wrap_new_SpreadToBenchmark__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SpreadToBenchmark";
  FIX::SpreadToBenchmark *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SpreadToBenchmark *)new FIX::SpreadToBenchmark();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SpreadToBenchmark_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SpreadToBenchmark_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SpreadToBenchmark);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SpreadToBenchmark__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SpreadToBenchmark";
  FIX::SpreadToBenchmark *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::SpreadToBenchmark", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::SpreadToBenchmark", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::SpreadToBenchmark *)new FIX::SpreadToBenchmark((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SpreadToBenchmark(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SpreadToBenchmark__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpreadToBenchmark__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SpreadToBenchmark.new", 
    "    SpreadToBenchmark.new()\n"
    "    SpreadToBenchmark.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SpreadToBenchmark(FIX::SpreadToBenchmark *arg1) {
    delete arg1;
}

swig_class SwigClassCommType;

SWIGINTERN VALUE
_wrap_new_CommType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CommType";
  FIX::CommType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CommType *)new FIX::CommType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CommType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CommType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CommType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CommType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CommType";
  FIX::CommType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::CommType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::CommType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::CommType *)new FIX::CommType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CommType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CommType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CommType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CommType.new", 
    "    CommType.new()\n"
    "    CommType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CommType(FIX::CommType *arg1) {
    delete arg1;
}

swig_class SwigClassRegistRejReasonCode;

SWIGINTERN VALUE
_wrap_new_RegistRejReasonCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonCode";
  FIX::RegistRejReasonCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistRejReasonCode *)new FIX::RegistRejReasonCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistRejReasonCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistRejReasonCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistRejReasonCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistRejReasonCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonCode";
  FIX::RegistRejReasonCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RegistRejReasonCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RegistRejReasonCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RegistRejReasonCode *)new FIX::RegistRejReasonCode((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistRejReasonCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistRejReasonCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistRejReasonCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistRejReasonCode.new", 
    "    RegistRejReasonCode.new()\n"
    "    RegistRejReasonCode.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistRejReasonCode(FIX::RegistRejReasonCode *arg1) {
    delete arg1;
}

swig_class SwigClassSideTimeInForce;

SWIGINTERN VALUE
_wrap_new_SideTimeInForce__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  FIX::SideTimeInForce *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SideTimeInForce__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  FIX::SideTimeInForce *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::SideTimeInForce", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SideTimeInForce__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  FIX::SideTimeInForce *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::SideTimeInForce", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::SideTimeInForce", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideTimeInForce_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideTimeInForce_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideTimeInForce);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideTimeInForce__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  FIX::SideTimeInForce *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::SideTimeInForce", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::SideTimeInForce", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::SideTimeInForce", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideTimeInForce(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideTimeInForce__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTimeInForce__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SideTimeInForce__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SideTimeInForce__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SideTimeInForce.new", 
    "    SideTimeInForce.new()\n"
    "    SideTimeInForce.new(bool showMilliseconds)\n"
    "    SideTimeInForce.new(FIX::UTCTIMESTAMP const &value)\n"
    "    SideTimeInForce.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTimeInForce(FIX::SideTimeInForce *arg1) {
    delete arg1;
}

swig_class SwigClassTrdRegTimestamp;

SWIGINTERN VALUE
_wrap_new_TrdRegTimestamp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  FIX::TrdRegTimestamp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TrdRegTimestamp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  FIX::TrdRegTimestamp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::TrdRegTimestamp", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TrdRegTimestamp__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  FIX::TrdRegTimestamp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TrdRegTimestamp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TrdRegTimestamp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdRegTimestamp_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdRegTimestamp_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdRegTimestamp);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdRegTimestamp__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  FIX::TrdRegTimestamp *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::TrdRegTimestamp", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::TrdRegTimestamp", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::TrdRegTimestamp", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdRegTimestamp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdRegTimestamp__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRegTimestamp__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TrdRegTimestamp__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TrdRegTimestamp__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TrdRegTimestamp.new", 
    "    TrdRegTimestamp.new()\n"
    "    TrdRegTimestamp.new(bool showMilliseconds)\n"
    "    TrdRegTimestamp.new(FIX::UTCTIMESTAMP const &value)\n"
    "    TrdRegTimestamp.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRegTimestamp(FIX::TrdRegTimestamp *arg1) {
    delete arg1;
}

swig_class SwigClassFinancialStatus;

SWIGINTERN VALUE
_wrap_new_FinancialStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FinancialStatus";
  FIX::FinancialStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FinancialStatus *)new FIX::FinancialStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FinancialStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FinancialStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FinancialStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FinancialStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FinancialStatus";
  FIX::FinancialStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::FinancialStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::FinancialStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::FinancialStatus *)new FIX::FinancialStatus((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FinancialStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FinancialStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FinancialStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FinancialStatus.new", 
    "    FinancialStatus.new()\n"
    "    FinancialStatus.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FinancialStatus(FIX::FinancialStatus *arg1) {
    delete arg1;
}

swig_class SwigClassNoTrades;

SWIGINTERN VALUE
_wrap_new_NoTrades__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTrades";
  FIX::NoTrades *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTrades *)new FIX::NoTrades();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTrades_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTrades_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTrades);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTrades__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrades";
  FIX::NoTrades *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTrades", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTrades", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTrades *)new FIX::NoTrades((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTrades(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTrades__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTrades__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTrades.new", 
    "    NoTrades.new()\n"
    "    NoTrades.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTrades(FIX::NoTrades *arg1) {
    delete arg1;
}

swig_class SwigClassLastFragment;

SWIGINTERN VALUE
_wrap_new_LastFragment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastFragment";
  FIX::LastFragment *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastFragment *)new FIX::LastFragment();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastFragment_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastFragment_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastFragment);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastFragment__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastFragment";
  FIX::LastFragment *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::LastFragment", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::LastFragment", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::LastFragment *)new FIX::LastFragment((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastFragment(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastFragment__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastFragment__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastFragment.new", 
    "    LastFragment.new()\n"
    "    LastFragment.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastFragment(FIX::LastFragment *arg1) {
    delete arg1;
}

swig_class SwigClassPartySubID;

SWIGINTERN VALUE
_wrap_new_PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PartySubID";
  FIX::PartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PartySubID *)new FIX::PartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartySubID";
  FIX::PartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PartySubID *)new FIX::PartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PartySubID.new", 
    "    PartySubID.new()\n"
    "    PartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PartySubID(FIX::PartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassAllocQty;

SWIGINTERN VALUE
_wrap_new_AllocQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocQty";
  FIX::AllocQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocQty *)new FIX::AllocQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocQty";
  FIX::AllocQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::AllocQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::AllocQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::AllocQty *)new FIX::AllocQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocQty.new", 
    "    AllocQty.new()\n"
    "    AllocQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocQty(FIX::AllocQty *arg1) {
    delete arg1;
}

swig_class SwigClassNotifyBrokerOfCredit;

SWIGINTERN VALUE
_wrap_new_NotifyBrokerOfCredit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NotifyBrokerOfCredit";
  FIX::NotifyBrokerOfCredit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NotifyBrokerOfCredit *)new FIX::NotifyBrokerOfCredit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NotifyBrokerOfCredit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NotifyBrokerOfCredit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NotifyBrokerOfCredit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NotifyBrokerOfCredit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotifyBrokerOfCredit";
  FIX::NotifyBrokerOfCredit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::NotifyBrokerOfCredit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::NotifyBrokerOfCredit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::NotifyBrokerOfCredit *)new FIX::NotifyBrokerOfCredit((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NotifyBrokerOfCredit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NotifyBrokerOfCredit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotifyBrokerOfCredit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NotifyBrokerOfCredit.new", 
    "    NotifyBrokerOfCredit.new()\n"
    "    NotifyBrokerOfCredit.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NotifyBrokerOfCredit(FIX::NotifyBrokerOfCredit *arg1) {
    delete arg1;
}

swig_class SwigClassSideTrdRegTimestampType;

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestampType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampType";
  FIX::SideTrdRegTimestampType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideTrdRegTimestampType *)new FIX::SideTrdRegTimestampType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideTrdRegTimestampType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideTrdRegTimestampType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideTrdRegTimestampType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestampType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampType";
  FIX::SideTrdRegTimestampType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideTrdRegTimestampType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideTrdRegTimestampType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideTrdRegTimestampType *)new FIX::SideTrdRegTimestampType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideTrdRegTimestampType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideTrdRegTimestampType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdRegTimestampType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideTrdRegTimestampType.new", 
    "    SideTrdRegTimestampType.new()\n"
    "    SideTrdRegTimestampType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdRegTimestampType(FIX::SideTrdRegTimestampType *arg1) {
    delete arg1;
}

swig_class SwigClassAgreementDate;

SWIGINTERN VALUE
_wrap_new_AgreementDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AgreementDate";
  FIX::AgreementDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AgreementDate *)new FIX::AgreementDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AgreementDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AgreementDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AgreementDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AgreementDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementDate";
  FIX::AgreementDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::AgreementDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::AgreementDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::AgreementDate *)new FIX::AgreementDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AgreementDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AgreementDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AgreementDate.new", 
    "    AgreementDate.new()\n"
    "    AgreementDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementDate(FIX::AgreementDate *arg1) {
    delete arg1;
}

swig_class SwigClassPartySubIDType;

SWIGINTERN VALUE
_wrap_new_PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PartySubIDType";
  FIX::PartySubIDType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PartySubIDType *)new FIX::PartySubIDType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PartySubIDType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PartySubIDType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PartySubIDType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PartySubIDType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartySubIDType";
  FIX::PartySubIDType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PartySubIDType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PartySubIDType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PartySubIDType *)new FIX::PartySubIDType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PartySubIDType.new", 
    "    PartySubIDType.new()\n"
    "    PartySubIDType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PartySubIDType(FIX::PartySubIDType *arg1) {
    delete arg1;
}

swig_class SwigClassTotalNetValue;

SWIGINTERN VALUE
_wrap_new_TotalNetValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotalNetValue";
  FIX::TotalNetValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotalNetValue *)new FIX::TotalNetValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotalNetValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotalNetValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotalNetValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotalNetValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNetValue";
  FIX::TotalNetValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::TotalNetValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::TotalNetValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::TotalNetValue *)new FIX::TotalNetValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotalNetValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotalNetValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNetValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotalNetValue.new", 
    "    TotalNetValue.new()\n"
    "    TotalNetValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNetValue(FIX::TotalNetValue *arg1) {
    delete arg1;
}

swig_class SwigClassAllocNoOrdersType;

SWIGINTERN VALUE
_wrap_new_AllocNoOrdersType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocNoOrdersType";
  FIX::AllocNoOrdersType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocNoOrdersType *)new FIX::AllocNoOrdersType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocNoOrdersType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocNoOrdersType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocNoOrdersType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocNoOrdersType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocNoOrdersType";
  FIX::AllocNoOrdersType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocNoOrdersType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocNoOrdersType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocNoOrdersType *)new FIX::AllocNoOrdersType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocNoOrdersType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocNoOrdersType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocNoOrdersType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocNoOrdersType.new", 
    "    AllocNoOrdersType.new()\n"
    "    AllocNoOrdersType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocNoOrdersType(FIX::AllocNoOrdersType *arg1) {
    delete arg1;
}

swig_class SwigClassAllocLinkID;

SWIGINTERN VALUE
_wrap_new_AllocLinkID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkID";
  FIX::AllocLinkID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocLinkID *)new FIX::AllocLinkID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocLinkID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocLinkID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocLinkID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocLinkID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkID";
  FIX::AllocLinkID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocLinkID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocLinkID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocLinkID *)new FIX::AllocLinkID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocLinkID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocLinkID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocLinkID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocLinkID.new", 
    "    AllocLinkID.new()\n"
    "    AllocLinkID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocLinkID(FIX::AllocLinkID *arg1) {
    delete arg1;
}

swig_class SwigClassRoundingModulus;

SWIGINTERN VALUE
_wrap_new_RoundingModulus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RoundingModulus";
  FIX::RoundingModulus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RoundingModulus *)new FIX::RoundingModulus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoundingModulus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoundingModulus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RoundingModulus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoundingModulus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundingModulus";
  FIX::RoundingModulus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::RoundingModulus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::RoundingModulus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::RoundingModulus *)new FIX::RoundingModulus((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RoundingModulus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RoundingModulus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoundingModulus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RoundingModulus.new", 
    "    RoundingModulus.new()\n"
    "    RoundingModulus.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RoundingModulus(FIX::RoundingModulus *arg1) {
    delete arg1;
}

swig_class SwigClassOnBehalfOfCompID;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfCompID";
  FIX::OnBehalfOfCompID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OnBehalfOfCompID *)new FIX::OnBehalfOfCompID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OnBehalfOfCompID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OnBehalfOfCompID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OnBehalfOfCompID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OnBehalfOfCompID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfCompID";
  FIX::OnBehalfOfCompID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OnBehalfOfCompID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OnBehalfOfCompID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OnBehalfOfCompID *)new FIX::OnBehalfOfCompID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OnBehalfOfCompID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OnBehalfOfCompID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfCompID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OnBehalfOfCompID.new", 
    "    OnBehalfOfCompID.new()\n"
    "    OnBehalfOfCompID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfCompID(FIX::OnBehalfOfCompID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityID;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityID";
  FIX::UnderlyingSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityID *)new FIX::UnderlyingSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityID";
  FIX::UnderlyingSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecurityID *)new FIX::UnderlyingSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityID.new", 
    "    UnderlyingSecurityID.new()\n"
    "    UnderlyingSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityID(FIX::UnderlyingSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassSettlObligMsgID;

SWIGINTERN VALUE
_wrap_new_SettlObligMsgID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMsgID";
  FIX::SettlObligMsgID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlObligMsgID *)new FIX::SettlObligMsgID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlObligMsgID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlObligMsgID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlObligMsgID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlObligMsgID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMsgID";
  FIX::SettlObligMsgID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlObligMsgID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlObligMsgID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlObligMsgID *)new FIX::SettlObligMsgID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlObligMsgID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlObligMsgID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligMsgID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlObligMsgID.new", 
    "    SettlObligMsgID.new()\n"
    "    SettlObligMsgID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligMsgID(FIX::SettlObligMsgID *arg1) {
    delete arg1;
}

swig_class SwigClassPositionLimit;

SWIGINTERN VALUE
_wrap_new_PositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PositionLimit";
  FIX::PositionLimit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PositionLimit *)new FIX::PositionLimit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PositionLimit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PositionLimit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PositionLimit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PositionLimit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionLimit";
  FIX::PositionLimit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PositionLimit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PositionLimit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PositionLimit *)new FIX::PositionLimit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PositionLimit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PositionLimit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionLimit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PositionLimit.new", 
    "    PositionLimit.new()\n"
    "    PositionLimit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PositionLimit(FIX::PositionLimit *arg1) {
    delete arg1;
}

swig_class SwigClassSharedCommission;

SWIGINTERN VALUE
_wrap_new_SharedCommission__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SharedCommission";
  FIX::SharedCommission *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SharedCommission *)new FIX::SharedCommission();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SharedCommission_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SharedCommission_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SharedCommission);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SharedCommission__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SharedCommission";
  FIX::SharedCommission *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::SharedCommission", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::SharedCommission", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::SharedCommission *)new FIX::SharedCommission((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SharedCommission(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SharedCommission__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SharedCommission__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SharedCommission.new", 
    "    SharedCommission.new()\n"
    "    SharedCommission.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SharedCommission(FIX::SharedCommission *arg1) {
    delete arg1;
}

swig_class SwigClassAllowableOneSidednessPct;

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessPct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessPct";
  FIX::AllowableOneSidednessPct *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllowableOneSidednessPct *)new FIX::AllowableOneSidednessPct();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllowableOneSidednessPct_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllowableOneSidednessPct_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllowableOneSidednessPct);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessPct__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessPct";
  FIX::AllowableOneSidednessPct *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::AllowableOneSidednessPct", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::AllowableOneSidednessPct", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::AllowableOneSidednessPct *)new FIX::AllowableOneSidednessPct((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllowableOneSidednessPct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllowableOneSidednessPct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllowableOneSidednessPct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllowableOneSidednessPct.new", 
    "    AllowableOneSidednessPct.new()\n"
    "    AllowableOneSidednessPct.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllowableOneSidednessPct(FIX::AllowableOneSidednessPct *arg1) {
    delete arg1;
}

swig_class SwigClassAllocText;

SWIGINTERN VALUE
_wrap_new_AllocText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocText";
  FIX::AllocText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocText *)new FIX::AllocText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocText";
  FIX::AllocText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AllocText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AllocText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AllocText *)new FIX::AllocText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocText.new", 
    "    AllocText.new()\n"
    "    AllocText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocText(FIX::AllocText *arg1) {
    delete arg1;
}

swig_class SwigClassEndSeqNo;

SWIGINTERN VALUE
_wrap_new_EndSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndSeqNo";
  FIX::EndSeqNo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndSeqNo *)new FIX::EndSeqNo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndSeqNo_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndSeqNo_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndSeqNo);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndSeqNo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndSeqNo";
  FIX::EndSeqNo *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::EndSeqNo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::EndSeqNo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::EndSeqNo *)new FIX::EndSeqNo((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndSeqNo(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndSeqNo__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndSeqNo__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndSeqNo.new", 
    "    EndSeqNo.new()\n"
    "    EndSeqNo.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndSeqNo(FIX::EndSeqNo *arg1) {
    delete arg1;
}

swig_class SwigClassNoPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoPartyIDs";
  FIX::NoPartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoPartyIDs *)new FIX::NoPartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoPartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoPartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoPartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyIDs";
  FIX::NoPartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoPartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoPartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartyIDs *)new FIX::NoPartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoPartyIDs.new", 
    "    NoPartyIDs.new()\n"
    "    NoPartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyIDs(FIX::NoPartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassNoContraBrokers;

SWIGINTERN VALUE
_wrap_new_NoContraBrokers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoContraBrokers";
  FIX::NoContraBrokers *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoContraBrokers *)new FIX::NoContraBrokers();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoContraBrokers_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoContraBrokers_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoContraBrokers);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoContraBrokers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContraBrokers";
  FIX::NoContraBrokers *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoContraBrokers", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoContraBrokers", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoContraBrokers *)new FIX::NoContraBrokers((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoContraBrokers(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoContraBrokers__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoContraBrokers__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoContraBrokers.new", 
    "    NoContraBrokers.new()\n"
    "    NoContraBrokers.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoContraBrokers(FIX::NoContraBrokers *arg1) {
    delete arg1;
}

swig_class SwigClassAllocLinkType;

SWIGINTERN VALUE
_wrap_new_AllocLinkType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkType";
  FIX::AllocLinkType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocLinkType *)new FIX::AllocLinkType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocLinkType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocLinkType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocLinkType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocLinkType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkType";
  FIX::AllocLinkType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocLinkType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocLinkType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocLinkType *)new FIX::AllocLinkType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocLinkType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocLinkType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocLinkType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocLinkType.new", 
    "    AllocLinkType.new()\n"
    "    AllocLinkType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocLinkType(FIX::AllocLinkType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingAllocationPercent;

SWIGINTERN VALUE
_wrap_new_UnderlyingAllocationPercent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAllocationPercent";
  FIX::UnderlyingAllocationPercent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingAllocationPercent *)new FIX::UnderlyingAllocationPercent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingAllocationPercent_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingAllocationPercent_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingAllocationPercent);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingAllocationPercent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAllocationPercent";
  FIX::UnderlyingAllocationPercent *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::UnderlyingAllocationPercent", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::UnderlyingAllocationPercent", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::UnderlyingAllocationPercent *)new FIX::UnderlyingAllocationPercent((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingAllocationPercent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingAllocationPercent__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingAllocationPercent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingAllocationPercent.new", 
    "    UnderlyingAllocationPercent.new()\n"
    "    UnderlyingAllocationPercent.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingAllocationPercent(FIX::UnderlyingAllocationPercent *arg1) {
    delete arg1;
}

swig_class SwigClassAllocAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_AllocAccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocAccruedInterestAmt";
  FIX::AllocAccruedInterestAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocAccruedInterestAmt *)new FIX::AllocAccruedInterestAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocAccruedInterestAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocAccruedInterestAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocAccruedInterestAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocAccruedInterestAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccruedInterestAmt";
  FIX::AllocAccruedInterestAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::AllocAccruedInterestAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::AllocAccruedInterestAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::AllocAccruedInterestAmt *)new FIX::AllocAccruedInterestAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocAccruedInterestAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocAccruedInterestAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAccruedInterestAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocAccruedInterestAmt.new", 
    "    AllocAccruedInterestAmt.new()\n"
    "    AllocAccruedInterestAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAccruedInterestAmt(FIX::AllocAccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedSecurityListDesc;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityListDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDesc";
  FIX::EncodedSecurityListDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedSecurityListDesc *)new FIX::EncodedSecurityListDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedSecurityListDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedSecurityListDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedSecurityListDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedSecurityListDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDesc";
  FIX::EncodedSecurityListDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedSecurityListDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedSecurityListDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedSecurityListDesc *)new FIX::EncodedSecurityListDesc((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSecurityListDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSecurityListDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityListDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedSecurityListDesc.new", 
    "    EncodedSecurityListDesc.new()\n"
    "    EncodedSecurityListDesc.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityListDesc(FIX::EncodedSecurityListDesc *arg1) {
    delete arg1;
}

swig_class SwigClassEncryptedPasswordLen;

SWIGINTERN VALUE
_wrap_new_EncryptedPasswordLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordLen";
  FIX::EncryptedPasswordLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncryptedPasswordLen *)new FIX::EncryptedPasswordLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncryptedPasswordLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncryptedPasswordLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncryptedPasswordLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncryptedPasswordLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordLen";
  FIX::EncryptedPasswordLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncryptedPasswordLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncryptedPasswordLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncryptedPasswordLen *)new FIX::EncryptedPasswordLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncryptedPasswordLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncryptedPasswordLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedPasswordLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncryptedPasswordLen.new", 
    "    EncryptedPasswordLen.new()\n"
    "    EncryptedPasswordLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedPasswordLen(FIX::EncryptedPasswordLen *arg1) {
    delete arg1;
}

swig_class SwigClassLegDividendYield;

SWIGINTERN VALUE
_wrap_new_LegDividendYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegDividendYield";
  FIX::LegDividendYield *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegDividendYield *)new FIX::LegDividendYield();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegDividendYield_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegDividendYield_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegDividendYield);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegDividendYield__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegDividendYield";
  FIX::LegDividendYield *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::LegDividendYield", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::LegDividendYield", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::LegDividendYield *)new FIX::LegDividendYield((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegDividendYield(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegDividendYield__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegDividendYield__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegDividendYield.new", 
    "    LegDividendYield.new()\n"
    "    LegDividendYield.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegDividendYield(FIX::LegDividendYield *arg1) {
    delete arg1;
}

swig_class SwigClassRefreshIndicator;

SWIGINTERN VALUE
_wrap_new_RefreshIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefreshIndicator";
  FIX::RefreshIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefreshIndicator *)new FIX::RefreshIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefreshIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefreshIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefreshIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefreshIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefreshIndicator";
  FIX::RefreshIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::RefreshIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::RefreshIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::RefreshIndicator *)new FIX::RefreshIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefreshIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefreshIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefreshIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefreshIndicator.new", 
    "    RefreshIndicator.new()\n"
    "    RefreshIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefreshIndicator(FIX::RefreshIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassSideSettlCurrency;

SWIGINTERN VALUE
_wrap_new_SideSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideSettlCurrency";
  FIX::SideSettlCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideSettlCurrency *)new FIX::SideSettlCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideSettlCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideSettlCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideSettlCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideSettlCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideSettlCurrency";
  FIX::SideSettlCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::SideSettlCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::SideSettlCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::SideSettlCurrency *)new FIX::SideSettlCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideSettlCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideSettlCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideSettlCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideSettlCurrency.new", 
    "    SideSettlCurrency.new()\n"
    "    SideSettlCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideSettlCurrency(FIX::SideSettlCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSettlementType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementType";
  FIX::UnderlyingSettlementType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSettlementType *)new FIX::UnderlyingSettlementType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSettlementType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSettlementType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSettlementType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementType";
  FIX::UnderlyingSettlementType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingSettlementType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingSettlementType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingSettlementType *)new FIX::UnderlyingSettlementType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSettlementType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSettlementType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlementType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSettlementType.new", 
    "    UnderlyingSettlementType.new()\n"
    "    UnderlyingSettlementType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlementType(FIX::UnderlyingSettlementType *arg1) {
    delete arg1;
}

swig_class SwigClassOrderCapacityQty;

SWIGINTERN VALUE
_wrap_new_OrderCapacityQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacityQty";
  FIX::OrderCapacityQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderCapacityQty *)new FIX::OrderCapacityQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderCapacityQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderCapacityQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderCapacityQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderCapacityQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacityQty";
  FIX::OrderCapacityQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::OrderCapacityQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::OrderCapacityQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::OrderCapacityQty *)new FIX::OrderCapacityQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderCapacityQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderCapacityQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderCapacityQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderCapacityQty.new", 
    "    OrderCapacityQty.new()\n"
    "    OrderCapacityQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderCapacityQty(FIX::OrderCapacityQty *arg1) {
    delete arg1;
}

swig_class SwigClassLongQty;

SWIGINTERN VALUE
_wrap_new_LongQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LongQty";
  FIX::LongQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LongQty *)new FIX::LongQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LongQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LongQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LongQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LongQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LongQty";
  FIX::LongQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LongQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LongQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LongQty *)new FIX::LongQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LongQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LongQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LongQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LongQty.new", 
    "    LongQty.new()\n"
    "    LongQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LongQty(FIX::LongQty *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSettlMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeSettlMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettlMethod";
  FIX::DerivativeSettlMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSettlMethod *)new FIX::DerivativeSettlMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSettlMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSettlMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSettlMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSettlMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettlMethod";
  FIX::DerivativeSettlMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DerivativeSettlMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DerivativeSettlMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DerivativeSettlMethod *)new FIX::DerivativeSettlMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSettlMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSettlMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSettlMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSettlMethod.new", 
    "    DerivativeSettlMethod.new()\n"
    "    DerivativeSettlMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSettlMethod(FIX::DerivativeSettlMethod *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerTradingSessionID;

SWIGINTERN VALUE
_wrap_new_TriggerTradingSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionID";
  FIX::TriggerTradingSessionID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerTradingSessionID *)new FIX::TriggerTradingSessionID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerTradingSessionID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerTradingSessionID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerTradingSessionID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerTradingSessionID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionID";
  FIX::TriggerTradingSessionID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TriggerTradingSessionID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TriggerTradingSessionID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TriggerTradingSessionID *)new FIX::TriggerTradingSessionID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerTradingSessionID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerTradingSessionID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerTradingSessionID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerTradingSessionID.new", 
    "    TriggerTradingSessionID.new()\n"
    "    TriggerTradingSessionID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerTradingSessionID(FIX::TriggerTradingSessionID *arg1) {
    delete arg1;
}

swig_class SwigClassDisplayMethod;

SWIGINTERN VALUE
_wrap_new_DisplayMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DisplayMethod";
  FIX::DisplayMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DisplayMethod *)new FIX::DisplayMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DisplayMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DisplayMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DisplayMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DisplayMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayMethod";
  FIX::DisplayMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DisplayMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DisplayMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DisplayMethod *)new FIX::DisplayMethod((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DisplayMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DisplayMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DisplayMethod.new", 
    "    DisplayMethod.new()\n"
    "    DisplayMethod.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayMethod(FIX::DisplayMethod *arg1) {
    delete arg1;
}

swig_class SwigClassRptSeq;

SWIGINTERN VALUE
_wrap_new_RptSeq__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RptSeq";
  FIX::RptSeq *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RptSeq *)new FIX::RptSeq();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RptSeq_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RptSeq_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RptSeq);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RptSeq__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RptSeq";
  FIX::RptSeq *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RptSeq", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RptSeq", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RptSeq *)new FIX::RptSeq((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RptSeq(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RptSeq__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RptSeq__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RptSeq.new", 
    "    RptSeq.new()\n"
    "    RptSeq.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RptSeq(FIX::RptSeq *arg1) {
    delete arg1;
}

swig_class SwigClassMDEntryOriginator;

SWIGINTERN VALUE
_wrap_new_MDEntryOriginator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDEntryOriginator";
  FIX::MDEntryOriginator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDEntryOriginator *)new FIX::MDEntryOriginator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDEntryOriginator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDEntryOriginator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDEntryOriginator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDEntryOriginator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryOriginator";
  FIX::MDEntryOriginator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDEntryOriginator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDEntryOriginator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDEntryOriginator *)new FIX::MDEntryOriginator((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDEntryOriginator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDEntryOriginator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryOriginator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDEntryOriginator.new", 
    "    MDEntryOriginator.new()\n"
    "    MDEntryOriginator.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryOriginator(FIX::MDEntryOriginator *arg1) {
    delete arg1;
}

swig_class SwigClassLegInstrRegistry;

SWIGINTERN VALUE
_wrap_new_LegInstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegInstrRegistry";
  FIX::LegInstrRegistry *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegInstrRegistry *)new FIX::LegInstrRegistry();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegInstrRegistry_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegInstrRegistry_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegInstrRegistry);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegInstrRegistry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegInstrRegistry";
  FIX::LegInstrRegistry *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegInstrRegistry", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegInstrRegistry", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegInstrRegistry *)new FIX::LegInstrRegistry((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegInstrRegistry(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegInstrRegistry__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegInstrRegistry__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegInstrRegistry.new", 
    "    LegInstrRegistry.new()\n"
    "    LegInstrRegistry.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegInstrRegistry(FIX::LegInstrRegistry *arg1) {
    delete arg1;
}

swig_class SwigClassFillQty;

SWIGINTERN VALUE
_wrap_new_FillQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FillQty";
  FIX::FillQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FillQty *)new FIX::FillQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FillQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FillQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FillQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FillQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillQty";
  FIX::FillQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::FillQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::FillQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::FillQty *)new FIX::FillQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FillQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FillQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FillQty.new", 
    "    FillQty.new()\n"
    "    FillQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FillQty(FIX::FillQty *arg1) {
    delete arg1;
}

swig_class SwigClassPegSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_PegSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityIDSource";
  FIX::PegSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PegSecurityIDSource *)new FIX::PegSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PegSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PegSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PegSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PegSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityIDSource";
  FIX::PegSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::PegSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::PegSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::PegSecurityIDSource *)new FIX::PegSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PegSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PegSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PegSecurityIDSource.new", 
    "    PegSecurityIDSource.new()\n"
    "    PegSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSecurityIDSource(FIX::PegSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityTime;

SWIGINTERN VALUE
_wrap_new_MaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityTime";
  FIX::MaturityTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityTime *)new FIX::MaturityTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityTime";
  FIX::MaturityTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::TZTIMEONLY const &","FIX::MaturityTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TZTIMEONLY const &","FIX::MaturityTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::MaturityTime *)new FIX::MaturityTime((FIX::TZTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityTime.new", 
    "    MaturityTime.new()\n"
    "    MaturityTime.new(FIX::TZTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityTime(FIX::MaturityTime *arg1) {
    delete arg1;
}

swig_class SwigClassMDFeedType;

SWIGINTERN VALUE
_wrap_new_MDFeedType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDFeedType";
  FIX::MDFeedType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDFeedType *)new FIX::MDFeedType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDFeedType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDFeedType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDFeedType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDFeedType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDFeedType";
  FIX::MDFeedType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::MDFeedType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::MDFeedType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::MDFeedType *)new FIX::MDFeedType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDFeedType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDFeedType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDFeedType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDFeedType.new", 
    "    MDFeedType.new()\n"
    "    MDFeedType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDFeedType(FIX::MDFeedType *arg1) {
    delete arg1;
}

swig_class SwigClassCollStatus;

SWIGINTERN VALUE
_wrap_new_CollStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollStatus";
  FIX::CollStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollStatus *)new FIX::CollStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollStatus";
  FIX::CollStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollStatus *)new FIX::CollStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollStatus.new", 
    "    CollStatus.new()\n"
    "    CollStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollStatus(FIX::CollStatus *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecuritySubType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecuritySubType";
  FIX::UnderlyingSecuritySubType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecuritySubType *)new FIX::UnderlyingSecuritySubType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecuritySubType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecuritySubType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecuritySubType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecuritySubType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecuritySubType";
  FIX::UnderlyingSecuritySubType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecuritySubType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecuritySubType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecuritySubType *)new FIX::UnderlyingSecuritySubType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecuritySubType.new", 
    "    UnderlyingSecuritySubType.new()\n"
    "    UnderlyingSecuritySubType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecuritySubType(FIX::UnderlyingSecuritySubType *arg1) {
    delete arg1;
}

swig_class SwigClassCstmApplVerID;

SWIGINTERN VALUE
_wrap_new_CstmApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CstmApplVerID";
  FIX::CstmApplVerID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CstmApplVerID *)new FIX::CstmApplVerID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CstmApplVerID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CstmApplVerID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CstmApplVerID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CstmApplVerID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CstmApplVerID";
  FIX::CstmApplVerID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CstmApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CstmApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CstmApplVerID *)new FIX::CstmApplVerID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CstmApplVerID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CstmApplVerID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CstmApplVerID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CstmApplVerID.new", 
    "    CstmApplVerID.new()\n"
    "    CstmApplVerID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CstmApplVerID(FIX::CstmApplVerID *arg1) {
    delete arg1;
}

swig_class SwigClassDefaultApplExtID;

SWIGINTERN VALUE
_wrap_new_DefaultApplExtID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplExtID";
  FIX::DefaultApplExtID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DefaultApplExtID *)new FIX::DefaultApplExtID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DefaultApplExtID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DefaultApplExtID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DefaultApplExtID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DefaultApplExtID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplExtID";
  FIX::DefaultApplExtID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DefaultApplExtID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DefaultApplExtID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DefaultApplExtID *)new FIX::DefaultApplExtID((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefaultApplExtID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DefaultApplExtID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultApplExtID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DefaultApplExtID.new", 
    "    DefaultApplExtID.new()\n"
    "    DefaultApplExtID.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultApplExtID(FIX::DefaultApplExtID *arg1) {
    delete arg1;
}

swig_class SwigClassNoDerivativeSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoDerivativeSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeSecurityAltID";
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDerivativeSecurityAltID *)new FIX::NoDerivativeSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDerivativeSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDerivativeSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDerivativeSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDerivativeSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeSecurityAltID";
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDerivativeSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDerivativeSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDerivativeSecurityAltID *)new FIX::NoDerivativeSecurityAltID((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDerivativeSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDerivativeSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDerivativeSecurityAltID.new", 
    "    NoDerivativeSecurityAltID.new()\n"
    "    NoDerivativeSecurityAltID.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeSecurityAltID(FIX::NoDerivativeSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassSideValueInd;

SWIGINTERN VALUE
_wrap_new_SideValueInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideValueInd";
  FIX::SideValueInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideValueInd *)new FIX::SideValueInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideValueInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideValueInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideValueInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideValueInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValueInd";
  FIX::SideValueInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SideValueInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SideValueInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SideValueInd *)new FIX::SideValueInd((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideValueInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideValueInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideValueInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideValueInd.new", 
    "    SideValueInd.new()\n"
    "    SideValueInd.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideValueInd(FIX::SideValueInd *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedText;

SWIGINTERN VALUE
_wrap_new_EncodedText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedText";
  FIX::EncodedText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedText *)new FIX::EncodedText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedText";
  FIX::EncodedText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedText *)new FIX::EncodedText((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedText.new", 
    "    EncodedText.new()\n"
    "    EncodedText.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedText(FIX::EncodedText *arg1) {
    delete arg1;
}

swig_class SwigClassAccount;

SWIGINTERN VALUE
_wrap_new_Account__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Account";
  FIX::Account *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Account *)new FIX::Account();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Account_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Account_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Account);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Account__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Account";
  FIX::Account *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Account", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Account", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Account *)new FIX::Account((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Account(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Account__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Account__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Account.new", 
    "    Account.new()\n"
    "    Account.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Account(FIX::Account *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerNewPrice;

SWIGINTERN VALUE
_wrap_new_TriggerNewPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewPrice";
  FIX::TriggerNewPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerNewPrice *)new FIX::TriggerNewPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerNewPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerNewPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerNewPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerNewPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewPrice";
  FIX::TriggerNewPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::TriggerNewPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::TriggerNewPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::TriggerNewPrice *)new FIX::TriggerNewPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerNewPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerNewPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerNewPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerNewPrice.new", 
    "    TriggerNewPrice.new()\n"
    "    TriggerNewPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerNewPrice(FIX::TriggerNewPrice *arg1) {
    delete arg1;
}

swig_class SwigClassUndlyInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyRole";
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UndlyInstrumentPartyRole *)new FIX::UndlyInstrumentPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UndlyInstrumentPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UndlyInstrumentPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UndlyInstrumentPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyRole";
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UndlyInstrumentPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UndlyInstrumentPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UndlyInstrumentPartyRole *)new FIX::UndlyInstrumentPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UndlyInstrumentPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UndlyInstrumentPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UndlyInstrumentPartyRole.new", 
    "    UndlyInstrumentPartyRole.new()\n"
    "    UndlyInstrumentPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartyRole(FIX::UndlyInstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassMsgDirection;

SWIGINTERN VALUE
_wrap_new_MsgDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MsgDirection";
  FIX::MsgDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MsgDirection *)new FIX::MsgDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MsgDirection_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MsgDirection_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MsgDirection);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MsgDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgDirection";
  FIX::MsgDirection *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MsgDirection", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MsgDirection", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MsgDirection *)new FIX::MsgDirection((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MsgDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MsgDirection__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MsgDirection__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MsgDirection.new", 
    "    MsgDirection.new()\n"
    "    MsgDirection.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MsgDirection(FIX::MsgDirection *arg1) {
    delete arg1;
}

swig_class SwigClassLegMaturityDate;

SWIGINTERN VALUE
_wrap_new_LegMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityDate";
  FIX::LegMaturityDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegMaturityDate *)new FIX::LegMaturityDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegMaturityDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegMaturityDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegMaturityDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegMaturityDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityDate";
  FIX::LegMaturityDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegMaturityDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegMaturityDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegMaturityDate *)new FIX::LegMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegMaturityDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegMaturityDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegMaturityDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegMaturityDate.new", 
    "    LegMaturityDate.new()\n"
    "    LegMaturityDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegMaturityDate(FIX::LegMaturityDate *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_UnderlyingContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplierUnit";
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingContractMultiplierUnit *)new FIX::UnderlyingContractMultiplierUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingContractMultiplierUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingContractMultiplierUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingContractMultiplierUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplierUnit";
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingContractMultiplierUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingContractMultiplierUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingContractMultiplierUnit *)new FIX::UnderlyingContractMultiplierUnit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingContractMultiplierUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingContractMultiplierUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingContractMultiplierUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingContractMultiplierUnit.new", 
    "    UnderlyingContractMultiplierUnit.new()\n"
    "    UnderlyingContractMultiplierUnit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingContractMultiplierUnit(FIX::UnderlyingContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class SwigClassInputSource;

SWIGINTERN VALUE
_wrap_new_InputSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InputSource";
  FIX::InputSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InputSource *)new FIX::InputSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InputSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InputSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InputSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InputSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InputSource";
  FIX::InputSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::InputSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::InputSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::InputSource *)new FIX::InputSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InputSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InputSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InputSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InputSource.new", 
    "    InputSource.new()\n"
    "    InputSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InputSource(FIX::InputSource *arg1) {
    delete arg1;
}

swig_class SwigClassMDUpdateAction;

SWIGINTERN VALUE
_wrap_new_MDUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateAction";
  FIX::MDUpdateAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDUpdateAction *)new FIX::MDUpdateAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDUpdateAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDUpdateAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDUpdateAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDUpdateAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateAction";
  FIX::MDUpdateAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MDUpdateAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MDUpdateAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MDUpdateAction *)new FIX::MDUpdateAction((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDUpdateAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDUpdateAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDUpdateAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDUpdateAction.new", 
    "    MDUpdateAction.new()\n"
    "    MDUpdateAction.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDUpdateAction(FIX::MDUpdateAction *arg1) {
    delete arg1;
}

swig_class SwigClassMatchStatus;

SWIGINTERN VALUE
_wrap_new_MatchStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MatchStatus";
  FIX::MatchStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MatchStatus *)new FIX::MatchStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MatchStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MatchStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MatchStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MatchStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchStatus";
  FIX::MatchStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MatchStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MatchStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MatchStatus *)new FIX::MatchStatus((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MatchStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MatchStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MatchStatus.new", 
    "    MatchStatus.new()\n"
    "    MatchStatus.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchStatus(FIX::MatchStatus *arg1) {
    delete arg1;
}

swig_class SwigClassRateSource;

SWIGINTERN VALUE
_wrap_new_RateSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RateSource";
  FIX::RateSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RateSource *)new FIX::RateSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RateSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RateSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RateSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RateSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RateSource";
  FIX::RateSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RateSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RateSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RateSource *)new FIX::RateSource((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RateSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RateSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RateSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RateSource.new", 
    "    RateSource.new()\n"
    "    RateSource.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RateSource(FIX::RateSource *arg1) {
    delete arg1;
}

swig_class SwigClassAllocPositionEffect;

SWIGINTERN VALUE
_wrap_new_AllocPositionEffect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocPositionEffect";
  FIX::AllocPositionEffect *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocPositionEffect *)new FIX::AllocPositionEffect();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocPositionEffect_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocPositionEffect_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocPositionEffect);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocPositionEffect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocPositionEffect";
  FIX::AllocPositionEffect *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::AllocPositionEffect", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::AllocPositionEffect", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::AllocPositionEffect *)new FIX::AllocPositionEffect((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocPositionEffect(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocPositionEffect__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocPositionEffect__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocPositionEffect.new", 
    "    AllocPositionEffect.new()\n"
    "    AllocPositionEffect.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocPositionEffect(FIX::AllocPositionEffect *arg1) {
    delete arg1;
}

swig_class SwigClassPartyIDSource;

SWIGINTERN VALUE
_wrap_new_PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PartyIDSource";
  FIX::PartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PartyIDSource *)new FIX::PartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyIDSource";
  FIX::PartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::PartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::PartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::PartyIDSource *)new FIX::PartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PartyIDSource.new", 
    "    PartyIDSource.new()\n"
    "    PartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyIDSource(FIX::PartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedUnderlyingIssuer;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuer";
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedUnderlyingIssuer *)new FIX::EncodedUnderlyingIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedUnderlyingIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedUnderlyingIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedUnderlyingIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuer";
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedUnderlyingIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedUnderlyingIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedUnderlyingIssuer *)new FIX::EncodedUnderlyingIssuer((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedUnderlyingIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedUnderlyingIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedUnderlyingIssuer.new", 
    "    EncodedUnderlyingIssuer.new()\n"
    "    EncodedUnderlyingIssuer.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingIssuer(FIX::EncodedUnderlyingIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassEncryptedPassword;

SWIGINTERN VALUE
_wrap_new_EncryptedPassword__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPassword";
  FIX::EncryptedPassword *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncryptedPassword *)new FIX::EncryptedPassword();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncryptedPassword_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncryptedPassword_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncryptedPassword);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncryptedPassword__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPassword";
  FIX::EncryptedPassword *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncryptedPassword", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncryptedPassword", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncryptedPassword *)new FIX::EncryptedPassword((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncryptedPassword(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncryptedPassword__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedPassword__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncryptedPassword.new", 
    "    EncryptedPassword.new()\n"
    "    EncryptedPassword.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedPassword(FIX::EncryptedPassword *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerNewQty;

SWIGINTERN VALUE
_wrap_new_TriggerNewQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewQty";
  FIX::TriggerNewQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerNewQty *)new FIX::TriggerNewQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerNewQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerNewQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerNewQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerNewQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewQty";
  FIX::TriggerNewQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::TriggerNewQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::TriggerNewQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::TriggerNewQty *)new FIX::TriggerNewQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerNewQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerNewQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerNewQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerNewQty.new", 
    "    TriggerNewQty.new()\n"
    "    TriggerNewQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerNewQty(FIX::TriggerNewQty *arg1) {
    delete arg1;
}

swig_class SwigClassLegLastForwardPoints;

SWIGINTERN VALUE
_wrap_new_LegLastForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegLastForwardPoints";
  FIX::LegLastForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegLastForwardPoints *)new FIX::LegLastForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegLastForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegLastForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegLastForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegLastForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastForwardPoints";
  FIX::LegLastForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::LegLastForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::LegLastForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::LegLastForwardPoints *)new FIX::LegLastForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegLastForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegLastForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLastForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegLastForwardPoints.new", 
    "    LegLastForwardPoints.new()\n"
    "    LegLastForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLastForwardPoints(FIX::LegLastForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassTotNumTradeReports;

SWIGINTERN VALUE
_wrap_new_TotNumTradeReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNumTradeReports";
  FIX::TotNumTradeReports *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNumTradeReports *)new FIX::TotNumTradeReports();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNumTradeReports_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNumTradeReports_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNumTradeReports);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNumTradeReports__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumTradeReports";
  FIX::TotNumTradeReports *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNumTradeReports", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNumTradeReports", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNumTradeReports *)new FIX::TotNumTradeReports((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNumTradeReports(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNumTradeReports__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNumTradeReports__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNumTradeReports.new", 
    "    TotNumTradeReports.new()\n"
    "    TotNumTradeReports.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNumTradeReports(FIX::TotNumTradeReports *arg1) {
    delete arg1;
}

swig_class SwigClassRefApplVerID;

SWIGINTERN VALUE
_wrap_new_RefApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefApplVerID";
  FIX::RefApplVerID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefApplVerID *)new FIX::RefApplVerID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefApplVerID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefApplVerID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefApplVerID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefApplVerID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplVerID";
  FIX::RefApplVerID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefApplVerID *)new FIX::RefApplVerID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefApplVerID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefApplVerID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplVerID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefApplVerID.new", 
    "    RefApplVerID.new()\n"
    "    RefApplVerID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplVerID(FIX::RefApplVerID *arg1) {
    delete arg1;
}

swig_class SwigClassLastSpotRate;

SWIGINTERN VALUE
_wrap_new_LastSpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastSpotRate";
  FIX::LastSpotRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastSpotRate *)new FIX::LastSpotRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastSpotRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastSpotRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastSpotRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastSpotRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastSpotRate";
  FIX::LastSpotRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::LastSpotRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::LastSpotRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::LastSpotRate *)new FIX::LastSpotRate((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastSpotRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastSpotRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastSpotRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastSpotRate.new", 
    "    LastSpotRate.new()\n"
    "    LastSpotRate.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastSpotRate(FIX::LastSpotRate *arg1) {
    delete arg1;
}

swig_class SwigClassPrice;

SWIGINTERN VALUE
_wrap_new_Price__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Price";
  FIX::Price *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Price *)new FIX::Price();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Price_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Price_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Price);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Price__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Price";
  FIX::Price *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::Price", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::Price", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::Price *)new FIX::Price((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Price(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Price__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Price__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Price.new", 
    "    Price.new()\n"
    "    Price.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Price(FIX::Price *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityIDSource";
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityIDSource *)new FIX::UnderlyingSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityIDSource";
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecurityIDSource *)new FIX::UnderlyingSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityIDSource.new", 
    "    UnderlyingSecurityIDSource.new()\n"
    "    UnderlyingSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityIDSource(FIX::UnderlyingSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoSecurityTypes;

SWIGINTERN VALUE
_wrap_new_TotNoSecurityTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoSecurityTypes";
  FIX::TotNoSecurityTypes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoSecurityTypes *)new FIX::TotNoSecurityTypes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoSecurityTypes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoSecurityTypes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoSecurityTypes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoSecurityTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoSecurityTypes";
  FIX::TotNoSecurityTypes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoSecurityTypes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoSecurityTypes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoSecurityTypes *)new FIX::TotNoSecurityTypes((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoSecurityTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoSecurityTypes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoSecurityTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoSecurityTypes.new", 
    "    TotNoSecurityTypes.new()\n"
    "    TotNoSecurityTypes.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoSecurityTypes(FIX::TotNoSecurityTypes *arg1) {
    delete arg1;
}

swig_class SwigClassReportedPx;

SWIGINTERN VALUE
_wrap_new_ReportedPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ReportedPx";
  FIX::ReportedPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ReportedPx *)new FIX::ReportedPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ReportedPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ReportedPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ReportedPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ReportedPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportedPx";
  FIX::ReportedPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::ReportedPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::ReportedPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::ReportedPx *)new FIX::ReportedPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ReportedPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ReportedPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReportedPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ReportedPx.new", 
    "    ReportedPx.new()\n"
    "    ReportedPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ReportedPx(FIX::ReportedPx *arg1) {
    delete arg1;
}

swig_class SwigClassLegSymbol;

SWIGINTERN VALUE
_wrap_new_LegSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSymbol";
  FIX::LegSymbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSymbol *)new FIX::LegSymbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSymbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSymbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSymbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSymbol";
  FIX::LegSymbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSymbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSymbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSymbol *)new FIX::LegSymbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSymbol.new", 
    "    LegSymbol.new()\n"
    "    LegSymbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSymbol(FIX::LegSymbol *arg1) {
    delete arg1;
}

swig_class SwigClassLegIssuer;

SWIGINTERN VALUE
_wrap_new_LegIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegIssuer";
  FIX::LegIssuer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegIssuer *)new FIX::LegIssuer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegIssuer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegIssuer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegIssuer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegIssuer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIssuer";
  FIX::LegIssuer *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegIssuer", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegIssuer", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegIssuer *)new FIX::LegIssuer((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegIssuer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegIssuer__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIssuer__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegIssuer.new", 
    "    LegIssuer.new()\n"
    "    LegIssuer.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIssuer(FIX::LegIssuer *arg1) {
    delete arg1;
}

swig_class SwigClassRegistDetls;

SWIGINTERN VALUE
_wrap_new_RegistDetls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RegistDetls";
  FIX::RegistDetls *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RegistDetls *)new FIX::RegistDetls();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RegistDetls_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RegistDetls_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RegistDetls);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RegistDetls__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistDetls";
  FIX::RegistDetls *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RegistDetls", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RegistDetls", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RegistDetls *)new FIX::RegistDetls((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RegistDetls(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RegistDetls__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistDetls__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RegistDetls.new", 
    "    RegistDetls.new()\n"
    "    RegistDetls.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistDetls(FIX::RegistDetls *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityID;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityID";
  FIX::UnderlyingLegSecurityID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityID *)new FIX::UnderlyingLegSecurityID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityID";
  FIX::UnderlyingLegSecurityID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityID *)new FIX::UnderlyingLegSecurityID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityID.new", 
    "    UnderlyingLegSecurityID.new()\n"
    "    UnderlyingLegSecurityID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityID(FIX::UnderlyingLegSecurityID *arg1) {
    delete arg1;
}

swig_class SwigClassMinLotSize;

SWIGINTERN VALUE
_wrap_new_MinLotSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinLotSize";
  FIX::MinLotSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinLotSize *)new FIX::MinLotSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinLotSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinLotSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinLotSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinLotSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinLotSize";
  FIX::MinLotSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MinLotSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MinLotSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MinLotSize *)new FIX::MinLotSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinLotSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinLotSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinLotSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinLotSize.new", 
    "    MinLotSize.new()\n"
    "    MinLotSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinLotSize(FIX::MinLotSize *arg1) {
    delete arg1;
}

swig_class SwigClassNumTickets;

SWIGINTERN VALUE
_wrap_new_NumTickets__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NumTickets";
  FIX::NumTickets *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NumTickets *)new FIX::NumTickets();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NumTickets_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NumTickets_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NumTickets);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NumTickets__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumTickets";
  FIX::NumTickets *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NumTickets", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NumTickets", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NumTickets *)new FIX::NumTickets((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NumTickets(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NumTickets__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumTickets__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NumTickets.new", 
    "    NumTickets.new()\n"
    "    NumTickets.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NumTickets(FIX::NumTickets *arg1) {
    delete arg1;
}

swig_class SwigClassLegLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_LegLocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegLocaleOfIssue";
  FIX::LegLocaleOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegLocaleOfIssue *)new FIX::LegLocaleOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegLocaleOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegLocaleOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegLocaleOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegLocaleOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLocaleOfIssue";
  FIX::LegLocaleOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegLocaleOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegLocaleOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegLocaleOfIssue *)new FIX::LegLocaleOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegLocaleOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegLocaleOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLocaleOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegLocaleOfIssue.new", 
    "    LegLocaleOfIssue.new()\n"
    "    LegLocaleOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLocaleOfIssue(FIX::LegLocaleOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassExchangeForPhysical;

SWIGINTERN VALUE
_wrap_new_ExchangeForPhysical__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExchangeForPhysical";
  FIX::ExchangeForPhysical *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExchangeForPhysical *)new FIX::ExchangeForPhysical();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExchangeForPhysical_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExchangeForPhysical_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExchangeForPhysical);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExchangeForPhysical__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeForPhysical";
  FIX::ExchangeForPhysical *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ExchangeForPhysical", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ExchangeForPhysical", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ExchangeForPhysical *)new FIX::ExchangeForPhysical((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExchangeForPhysical(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExchangeForPhysical__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExchangeForPhysical__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExchangeForPhysical.new", 
    "    ExchangeForPhysical.new()\n"
    "    ExchangeForPhysical.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExchangeForPhysical(FIX::ExchangeForPhysical *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityTradingEvent;

SWIGINTERN VALUE
_wrap_new_SecurityTradingEvent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingEvent";
  FIX::SecurityTradingEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityTradingEvent *)new FIX::SecurityTradingEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityTradingEvent_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityTradingEvent_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityTradingEvent);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityTradingEvent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingEvent";
  FIX::SecurityTradingEvent *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityTradingEvent", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityTradingEvent", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityTradingEvent *)new FIX::SecurityTradingEvent((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityTradingEvent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityTradingEvent__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityTradingEvent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityTradingEvent.new", 
    "    SecurityTradingEvent.new()\n"
    "    SecurityTradingEvent.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityTradingEvent(FIX::SecurityTradingEvent *arg1) {
    delete arg1;
}

swig_class SwigClassMinPriceIncrementAmount;

SWIGINTERN VALUE
_wrap_new_MinPriceIncrementAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrementAmount";
  FIX::MinPriceIncrementAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MinPriceIncrementAmount *)new FIX::MinPriceIncrementAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MinPriceIncrementAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MinPriceIncrementAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MinPriceIncrementAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MinPriceIncrementAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrementAmount";
  FIX::MinPriceIncrementAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::MinPriceIncrementAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::MinPriceIncrementAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::MinPriceIncrementAmount *)new FIX::MinPriceIncrementAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MinPriceIncrementAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinPriceIncrementAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinPriceIncrementAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinPriceIncrementAmount.new", 
    "    MinPriceIncrementAmount.new()\n"
    "    MinPriceIncrementAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MinPriceIncrementAmount(FIX::MinPriceIncrementAmount *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingPayAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingPayAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPayAmount";
  FIX::UnderlyingPayAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingPayAmount *)new FIX::UnderlyingPayAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingPayAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingPayAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingPayAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingPayAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPayAmount";
  FIX::UnderlyingPayAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::UnderlyingPayAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::UnderlyingPayAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::UnderlyingPayAmount *)new FIX::UnderlyingPayAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingPayAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingPayAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPayAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingPayAmount.new", 
    "    UnderlyingPayAmount.new()\n"
    "    UnderlyingPayAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPayAmount(FIX::UnderlyingPayAmount *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPartySubID;

SWIGINTERN VALUE
_wrap_new_SettlPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubID";
  FIX::SettlPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPartySubID *)new FIX::SettlPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubID";
  FIX::SettlPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlPartySubID *)new FIX::SettlPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPartySubID.new", 
    "    SettlPartySubID.new()\n"
    "    SettlPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartySubID(FIX::SettlPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassAllocNetMoney;

SWIGINTERN VALUE
_wrap_new_AllocNetMoney__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocNetMoney";
  FIX::AllocNetMoney *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocNetMoney *)new FIX::AllocNetMoney();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocNetMoney_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocNetMoney_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocNetMoney);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocNetMoney__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocNetMoney";
  FIX::AllocNetMoney *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::AllocNetMoney", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::AllocNetMoney", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::AllocNetMoney *)new FIX::AllocNetMoney((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocNetMoney(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocNetMoney__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocNetMoney__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocNetMoney.new", 
    "    AllocNetMoney.new()\n"
    "    AllocNetMoney.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocNetMoney(FIX::AllocNetMoney *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingMaturityDay;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityDay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDay";
  FIX::UnderlyingMaturityDay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingMaturityDay *)new FIX::UnderlyingMaturityDay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingMaturityDay_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingMaturityDay_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingMaturityDay);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityDay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DAYOFMONTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDay";
  FIX::UnderlyingMaturityDay *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DAYOFMONTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DAYOFMONTH const &","FIX::UnderlyingMaturityDay", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DAYOFMONTH const &","FIX::UnderlyingMaturityDay", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DAYOFMONTH * >(argp1);
  result = (FIX::UnderlyingMaturityDay *)new FIX::UnderlyingMaturityDay((FIX::DAYOFMONTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingMaturityDay(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingMaturityDay__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DAYOFMONTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityDay__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingMaturityDay.new", 
    "    UnderlyingMaturityDay.new()\n"
    "    UnderlyingMaturityDay.new(FIX::DAYOFMONTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityDay(FIX::UnderlyingMaturityDay *arg1) {
    delete arg1;
}

swig_class SwigClassNetworkResponseID;

SWIGINTERN VALUE
_wrap_new_NetworkResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetworkResponseID";
  FIX::NetworkResponseID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetworkResponseID *)new FIX::NetworkResponseID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetworkResponseID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetworkResponseID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetworkResponseID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetworkResponseID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkResponseID";
  FIX::NetworkResponseID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NetworkResponseID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NetworkResponseID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NetworkResponseID *)new FIX::NetworkResponseID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetworkResponseID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetworkResponseID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkResponseID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetworkResponseID.new", 
    "    NetworkResponseID.new()\n"
    "    NetworkResponseID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkResponseID(FIX::NetworkResponseID *arg1) {
    delete arg1;
}

swig_class SwigClassNumBidders;

SWIGINTERN VALUE
_wrap_new_NumBidders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NumBidders";
  FIX::NumBidders *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NumBidders *)new FIX::NumBidders();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NumBidders_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NumBidders_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NumBidders);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NumBidders__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumBidders";
  FIX::NumBidders *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NumBidders", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NumBidders", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NumBidders *)new FIX::NumBidders((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NumBidders(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NumBidders__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumBidders__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NumBidders.new", 
    "    NumBidders.new()\n"
    "    NumBidders.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NumBidders(FIX::NumBidders *arg1) {
    delete arg1;
}

swig_class SwigClassAllocAcctIDSource;

SWIGINTERN VALUE
_wrap_new_AllocAcctIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocAcctIDSource";
  FIX::AllocAcctIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocAcctIDSource *)new FIX::AllocAcctIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocAcctIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocAcctIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocAcctIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocAcctIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAcctIDSource";
  FIX::AllocAcctIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocAcctIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocAcctIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocAcctIDSource *)new FIX::AllocAcctIDSource((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocAcctIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocAcctIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAcctIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocAcctIDSource.new", 
    "    AllocAcctIDSource.new()\n"
    "    AllocAcctIDSource.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAcctIDSource(FIX::AllocAcctIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassAllocAvgPx;

SWIGINTERN VALUE
_wrap_new_AllocAvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocAvgPx";
  FIX::AllocAvgPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocAvgPx *)new FIX::AllocAvgPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocAvgPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocAvgPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocAvgPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocAvgPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAvgPx";
  FIX::AllocAvgPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::AllocAvgPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::AllocAvgPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::AllocAvgPx *)new FIX::AllocAvgPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocAvgPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocAvgPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAvgPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocAvgPx.new", 
    "    AllocAvgPx.new()\n"
    "    AllocAvgPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAvgPx(FIX::AllocAvgPx *arg1) {
    delete arg1;
}

swig_class SwigClassSecuritySettlAgentCode;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentCode";
  FIX::SecuritySettlAgentCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecuritySettlAgentCode *)new FIX::SecuritySettlAgentCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecuritySettlAgentCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecuritySettlAgentCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecuritySettlAgentCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentCode";
  FIX::SecuritySettlAgentCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecuritySettlAgentCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecuritySettlAgentCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecuritySettlAgentCode *)new FIX::SecuritySettlAgentCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecuritySettlAgentCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecuritySettlAgentCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecuritySettlAgentCode.new", 
    "    SecuritySettlAgentCode.new()\n"
    "    SecuritySettlAgentCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentCode(FIX::SecuritySettlAgentCode *arg1) {
    delete arg1;
}

swig_class SwigClassNoDistribInsts;

SWIGINTERN VALUE
_wrap_new_NoDistribInsts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDistribInsts";
  FIX::NoDistribInsts *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDistribInsts *)new FIX::NoDistribInsts();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDistribInsts_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDistribInsts_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDistribInsts);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDistribInsts__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDistribInsts";
  FIX::NoDistribInsts *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDistribInsts", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDistribInsts", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDistribInsts *)new FIX::NoDistribInsts((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDistribInsts(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDistribInsts__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDistribInsts__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDistribInsts.new", 
    "    NoDistribInsts.new()\n"
    "    NoDistribInsts.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDistribInsts(FIX::NoDistribInsts *arg1) {
    delete arg1;
}

swig_class SwigClassCustDirectedOrder;

SWIGINTERN VALUE
_wrap_new_CustDirectedOrder__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CustDirectedOrder";
  FIX::CustDirectedOrder *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CustDirectedOrder *)new FIX::CustDirectedOrder();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CustDirectedOrder_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CustDirectedOrder_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CustDirectedOrder);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CustDirectedOrder__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustDirectedOrder";
  FIX::CustDirectedOrder *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::CustDirectedOrder", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::CustDirectedOrder", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::CustDirectedOrder *)new FIX::CustDirectedOrder((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CustDirectedOrder(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CustDirectedOrder__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustDirectedOrder__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CustDirectedOrder.new", 
    "    CustDirectedOrder.new()\n"
    "    CustDirectedOrder.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CustDirectedOrder(FIX::CustDirectedOrder *arg1) {
    delete arg1;
}

swig_class SwigClassFairValue;

SWIGINTERN VALUE
_wrap_new_FairValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FairValue";
  FIX::FairValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FairValue *)new FIX::FairValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FairValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FairValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FairValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FairValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FairValue";
  FIX::FairValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::FairValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::FairValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::FairValue *)new FIX::FairValue((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FairValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FairValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FairValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FairValue.new", 
    "    FairValue.new()\n"
    "    FairValue.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FairValue(FIX::FairValue *arg1) {
    delete arg1;
}

swig_class SwigClassNoStrikes;

SWIGINTERN VALUE
_wrap_new_NoStrikes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoStrikes";
  FIX::NoStrikes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoStrikes *)new FIX::NoStrikes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoStrikes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoStrikes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoStrikes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoStrikes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrikes";
  FIX::NoStrikes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoStrikes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoStrikes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoStrikes *)new FIX::NoStrikes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoStrikes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoStrikes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStrikes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoStrikes.new", 
    "    NoStrikes.new()\n"
    "    NoStrikes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStrikes(FIX::NoStrikes *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedSecurityListDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityListDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDescLen";
  FIX::EncodedSecurityListDescLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedSecurityListDescLen *)new FIX::EncodedSecurityListDescLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedSecurityListDescLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedSecurityListDescLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedSecurityListDescLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedSecurityListDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDescLen";
  FIX::EncodedSecurityListDescLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedSecurityListDescLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedSecurityListDescLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedSecurityListDescLen *)new FIX::EncodedSecurityListDescLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSecurityListDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSecurityListDescLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityListDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedSecurityListDescLen.new", 
    "    EncodedSecurityListDescLen.new()\n"
    "    EncodedSecurityListDescLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityListDescLen(FIX::EncodedSecurityListDescLen *arg1) {
    delete arg1;
}

swig_class SwigClassLegExerciseStyle;

SWIGINTERN VALUE
_wrap_new_LegExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegExerciseStyle";
  FIX::LegExerciseStyle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegExerciseStyle *)new FIX::LegExerciseStyle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegExerciseStyle_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegExerciseStyle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegExerciseStyle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegExerciseStyle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegExerciseStyle";
  FIX::LegExerciseStyle *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegExerciseStyle", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegExerciseStyle", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegExerciseStyle *)new FIX::LegExerciseStyle((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegExerciseStyle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegExerciseStyle__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegExerciseStyle__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegExerciseStyle.new", 
    "    LegExerciseStyle.new()\n"
    "    LegExerciseStyle.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegExerciseStyle(FIX::LegExerciseStyle *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSymbolSfx;

SWIGINTERN VALUE
_wrap_new_DerivativeSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbolSfx";
  FIX::DerivativeSymbolSfx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSymbolSfx *)new FIX::DerivativeSymbolSfx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSymbolSfx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSymbolSfx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSymbolSfx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSymbolSfx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbolSfx";
  FIX::DerivativeSymbolSfx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSymbolSfx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSymbolSfx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSymbolSfx *)new FIX::DerivativeSymbolSfx((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSymbolSfx.new", 
    "    DerivativeSymbolSfx.new()\n"
    "    DerivativeSymbolSfx.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSymbolSfx(FIX::DerivativeSymbolSfx *arg1) {
    delete arg1;
}

swig_class SwigClassNestedInstrAttribType;

SWIGINTERN VALUE
_wrap_new_NestedInstrAttribType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribType";
  FIX::NestedInstrAttribType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NestedInstrAttribType *)new FIX::NestedInstrAttribType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NestedInstrAttribType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NestedInstrAttribType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NestedInstrAttribType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NestedInstrAttribType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribType";
  FIX::NestedInstrAttribType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NestedInstrAttribType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NestedInstrAttribType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NestedInstrAttribType *)new FIX::NestedInstrAttribType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NestedInstrAttribType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NestedInstrAttribType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedInstrAttribType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NestedInstrAttribType.new", 
    "    NestedInstrAttribType.new()\n"
    "    NestedInstrAttribType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedInstrAttribType(FIX::NestedInstrAttribType *arg1) {
    delete arg1;
}

swig_class SwigClassContraTrader;

SWIGINTERN VALUE
_wrap_new_ContraTrader__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContraTrader";
  FIX::ContraTrader *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContraTrader *)new FIX::ContraTrader();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContraTrader_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContraTrader_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContraTrader);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContraTrader__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTrader";
  FIX::ContraTrader *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ContraTrader", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ContraTrader", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ContraTrader *)new FIX::ContraTrader((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContraTrader(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContraTrader__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraTrader__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContraTrader.new", 
    "    ContraTrader.new()\n"
    "    ContraTrader.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraTrader(FIX::ContraTrader *arg1) {
    delete arg1;
}

swig_class SwigClassMDSecSize;

SWIGINTERN VALUE
_wrap_new_MDSecSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDSecSize";
  FIX::MDSecSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDSecSize *)new FIX::MDSecSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDSecSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDSecSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDSecSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDSecSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSecSize";
  FIX::MDSecSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MDSecSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MDSecSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MDSecSize *)new FIX::MDSecSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDSecSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDSecSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDSecSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDSecSize.new", 
    "    MDSecSize.new()\n"
    "    MDSecSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDSecSize(FIX::MDSecSize *arg1) {
    delete arg1;
}

swig_class SwigClassNoOfSecSizes;

SWIGINTERN VALUE
_wrap_new_NoOfSecSizes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoOfSecSizes";
  FIX::NoOfSecSizes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoOfSecSizes *)new FIX::NoOfSecSizes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoOfSecSizes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoOfSecSizes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoOfSecSizes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoOfSecSizes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOfSecSizes";
  FIX::NoOfSecSizes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoOfSecSizes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoOfSecSizes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoOfSecSizes *)new FIX::NoOfSecSizes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoOfSecSizes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoOfSecSizes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOfSecSizes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoOfSecSizes.new", 
    "    NoOfSecSizes.new()\n"
    "    NoOfSecSizes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOfSecSizes(FIX::NoOfSecSizes *arg1) {
    delete arg1;
}

swig_class SwigClassCollAction;

SWIGINTERN VALUE
_wrap_new_CollAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAction";
  FIX::CollAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAction *)new FIX::CollAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAction";
  FIX::CollAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CollAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CollAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CollAction *)new FIX::CollAction((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAction.new", 
    "    CollAction.new()\n"
    "    CollAction.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAction(FIX::CollAction *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLastQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastQty";
  FIX::UnderlyingLastQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLastQty *)new FIX::UnderlyingLastQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLastQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLastQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLastQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLastQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastQty";
  FIX::UnderlyingLastQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::UnderlyingLastQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::UnderlyingLastQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::UnderlyingLastQty *)new FIX::UnderlyingLastQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLastQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLastQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLastQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLastQty.new", 
    "    UnderlyingLastQty.new()\n"
    "    UnderlyingLastQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLastQty(FIX::UnderlyingLastQty *arg1) {
    delete arg1;
}

swig_class SwigClassPossDupFlag;

SWIGINTERN VALUE
_wrap_new_PossDupFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PossDupFlag";
  FIX::PossDupFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PossDupFlag *)new FIX::PossDupFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PossDupFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PossDupFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PossDupFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PossDupFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PossDupFlag";
  FIX::PossDupFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PossDupFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PossDupFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PossDupFlag *)new FIX::PossDupFlag((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PossDupFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PossDupFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PossDupFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PossDupFlag.new", 
    "    PossDupFlag.new()\n"
    "    PossDupFlag.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PossDupFlag(FIX::PossDupFlag *arg1) {
    delete arg1;
}

swig_class SwigClassListStatusType;

SWIGINTERN VALUE
_wrap_new_ListStatusType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListStatusType";
  FIX::ListStatusType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListStatusType *)new FIX::ListStatusType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListStatusType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListStatusType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListStatusType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListStatusType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListStatusType";
  FIX::ListStatusType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ListStatusType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ListStatusType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ListStatusType *)new FIX::ListStatusType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListStatusType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListStatusType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListStatusType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListStatusType.new", 
    "    ListStatusType.new()\n"
    "    ListStatusType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListStatusType(FIX::ListStatusType *arg1) {
    delete arg1;
}

swig_class SwigClassSideFillStationCd;

SWIGINTERN VALUE
_wrap_new_SideFillStationCd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SideFillStationCd";
  FIX::SideFillStationCd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SideFillStationCd *)new FIX::SideFillStationCd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SideFillStationCd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SideFillStationCd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SideFillStationCd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SideFillStationCd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideFillStationCd";
  FIX::SideFillStationCd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SideFillStationCd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SideFillStationCd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SideFillStationCd *)new FIX::SideFillStationCd((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SideFillStationCd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SideFillStationCd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideFillStationCd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SideFillStationCd.new", 
    "    SideFillStationCd.new()\n"
    "    SideFillStationCd.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SideFillStationCd(FIX::SideFillStationCd *arg1) {
    delete arg1;
}

swig_class SwigClassStatusText;

SWIGINTERN VALUE
_wrap_new_StatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StatusText";
  FIX::StatusText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StatusText *)new FIX::StatusText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StatusText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StatusText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StatusText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StatusText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatusText";
  FIX::StatusText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StatusText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StatusText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StatusText *)new FIX::StatusText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StatusText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StatusText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StatusText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StatusText.new", 
    "    StatusText.new()\n"
    "    StatusText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StatusText(FIX::StatusText *arg1) {
    delete arg1;
}

swig_class SwigClassBasisFeatureDate;

SWIGINTERN VALUE
_wrap_new_BasisFeatureDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BasisFeatureDate";
  FIX::BasisFeatureDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BasisFeatureDate *)new FIX::BasisFeatureDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BasisFeatureDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BasisFeatureDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BasisFeatureDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BasisFeatureDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisFeatureDate";
  FIX::BasisFeatureDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::BasisFeatureDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::BasisFeatureDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::BasisFeatureDate *)new FIX::BasisFeatureDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BasisFeatureDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BasisFeatureDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BasisFeatureDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BasisFeatureDate.new", 
    "    BasisFeatureDate.new()\n"
    "    BasisFeatureDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BasisFeatureDate(FIX::BasisFeatureDate *arg1) {
    delete arg1;
}

swig_class SwigClassXmlDataLen;

SWIGINTERN VALUE
_wrap_new_XmlDataLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::XmlDataLen";
  FIX::XmlDataLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::XmlDataLen *)new FIX::XmlDataLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_XmlDataLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_XmlDataLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__XmlDataLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_XmlDataLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::XmlDataLen";
  FIX::XmlDataLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::XmlDataLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::XmlDataLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::XmlDataLen *)new FIX::XmlDataLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_XmlDataLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_XmlDataLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XmlDataLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "XmlDataLen.new", 
    "    XmlDataLen.new()\n"
    "    XmlDataLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_XmlDataLen(FIX::XmlDataLen *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingMaturityDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDate";
  FIX::UnderlyingMaturityDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingMaturityDate *)new FIX::UnderlyingMaturityDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingMaturityDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingMaturityDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingMaturityDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDate";
  FIX::UnderlyingMaturityDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::UnderlyingMaturityDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::UnderlyingMaturityDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::UnderlyingMaturityDate *)new FIX::UnderlyingMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingMaturityDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingMaturityDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingMaturityDate.new", 
    "    UnderlyingMaturityDate.new()\n"
    "    UnderlyingMaturityDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityDate(FIX::UnderlyingMaturityDate *arg1) {
    delete arg1;
}

swig_class SwigClassGapFillFlag;

SWIGINTERN VALUE
_wrap_new_GapFillFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::GapFillFlag";
  FIX::GapFillFlag *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::GapFillFlag *)new FIX::GapFillFlag();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_GapFillFlag_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_GapFillFlag_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__GapFillFlag);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_GapFillFlag__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GapFillFlag";
  FIX::GapFillFlag *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::GapFillFlag", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::GapFillFlag", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::GapFillFlag *)new FIX::GapFillFlag((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GapFillFlag(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_GapFillFlag__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GapFillFlag__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GapFillFlag.new", 
    "    GapFillFlag.new()\n"
    "    GapFillFlag.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_GapFillFlag(FIX::GapFillFlag *arg1) {
    delete arg1;
}

swig_class SwigClassRefApplExtID;

SWIGINTERN VALUE
_wrap_new_RefApplExtID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefApplExtID";
  FIX::RefApplExtID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefApplExtID *)new FIX::RefApplExtID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefApplExtID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefApplExtID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefApplExtID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefApplExtID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplExtID";
  FIX::RefApplExtID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RefApplExtID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RefApplExtID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RefApplExtID *)new FIX::RefApplExtID((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefApplExtID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefApplExtID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplExtID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefApplExtID.new", 
    "    RefApplExtID.new()\n"
    "    RefApplExtID.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplExtID(FIX::RefApplExtID *arg1) {
    delete arg1;
}

swig_class SwigClassRefApplID;

SWIGINTERN VALUE
_wrap_new_RefApplID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefApplID";
  FIX::RefApplID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefApplID *)new FIX::RefApplID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefApplID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefApplID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefApplID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefApplID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplID";
  FIX::RefApplID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RefApplID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RefApplID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RefApplID *)new FIX::RefApplID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefApplID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefApplID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefApplID.new", 
    "    RefApplID.new()\n"
    "    RefApplID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplID(FIX::RefApplID *arg1) {
    delete arg1;
}

swig_class SwigClassNoTradingSessionRules;

SWIGINTERN VALUE
_wrap_new_NoTradingSessionRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessionRules";
  FIX::NoTradingSessionRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTradingSessionRules *)new FIX::NoTradingSessionRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTradingSessionRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTradingSessionRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTradingSessionRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTradingSessionRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessionRules";
  FIX::NoTradingSessionRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTradingSessionRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTradingSessionRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTradingSessionRules *)new FIX::NoTradingSessionRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTradingSessionRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTradingSessionRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTradingSessionRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTradingSessionRules.new", 
    "    NoTradingSessionRules.new()\n"
    "    NoTradingSessionRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTradingSessionRules(FIX::NoTradingSessionRules *arg1) {
    delete arg1;
}

swig_class SwigClassSwapPoints;

SWIGINTERN VALUE
_wrap_new_SwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SwapPoints";
  FIX::SwapPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SwapPoints *)new FIX::SwapPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SwapPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SwapPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SwapPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SwapPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SwapPoints";
  FIX::SwapPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::SwapPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::SwapPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::SwapPoints *)new FIX::SwapPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SwapPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SwapPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SwapPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SwapPoints.new", 
    "    SwapPoints.new()\n"
    "    SwapPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SwapPoints(FIX::SwapPoints *arg1) {
    delete arg1;
}

swig_class SwigClassTargetStrategyParameters;

SWIGINTERN VALUE
_wrap_new_TargetStrategyParameters__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyParameters";
  FIX::TargetStrategyParameters *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetStrategyParameters *)new FIX::TargetStrategyParameters();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetStrategyParameters_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetStrategyParameters_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetStrategyParameters);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetStrategyParameters__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyParameters";
  FIX::TargetStrategyParameters *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TargetStrategyParameters", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TargetStrategyParameters", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TargetStrategyParameters *)new FIX::TargetStrategyParameters((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetStrategyParameters(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetStrategyParameters__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetStrategyParameters__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetStrategyParameters.new", 
    "    TargetStrategyParameters.new()\n"
    "    TargetStrategyParameters.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetStrategyParameters(FIX::TargetStrategyParameters *arg1) {
    delete arg1;
}

swig_class SwigClassLastForwardPoints;

SWIGINTERN VALUE
_wrap_new_LastForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints";
  FIX::LastForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastForwardPoints *)new FIX::LastForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints";
  FIX::LastForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::LastForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::LastForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::LastForwardPoints *)new FIX::LastForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastForwardPoints.new", 
    "    LastForwardPoints.new()\n"
    "    LastForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastForwardPoints(FIX::LastForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassYieldRedemptionDate;

SWIGINTERN VALUE
_wrap_new_YieldRedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionDate";
  FIX::YieldRedemptionDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::YieldRedemptionDate *)new FIX::YieldRedemptionDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_YieldRedemptionDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_YieldRedemptionDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__YieldRedemptionDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_YieldRedemptionDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionDate";
  FIX::YieldRedemptionDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::YieldRedemptionDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::YieldRedemptionDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::YieldRedemptionDate *)new FIX::YieldRedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_YieldRedemptionDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_YieldRedemptionDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldRedemptionDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "YieldRedemptionDate.new", 
    "    YieldRedemptionDate.new()\n"
    "    YieldRedemptionDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldRedemptionDate(FIX::YieldRedemptionDate *arg1) {
    delete arg1;
}

swig_class SwigClassNoSettlDetails;

SWIGINTERN VALUE
_wrap_new_NoSettlDetails__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSettlDetails";
  FIX::NoSettlDetails *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSettlDetails *)new FIX::NoSettlDetails();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSettlDetails_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSettlDetails_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSettlDetails);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSettlDetails__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlDetails";
  FIX::NoSettlDetails *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSettlDetails", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSettlDetails", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSettlDetails *)new FIX::NoSettlDetails((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSettlDetails(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSettlDetails__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlDetails__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSettlDetails.new", 
    "    NoSettlDetails.new()\n"
    "    NoSettlDetails.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlDetails(FIX::NoSettlDetails *arg1) {
    delete arg1;
}

swig_class SwigClassTradeHandlingInstr;

SWIGINTERN VALUE
_wrap_new_TradeHandlingInstr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeHandlingInstr";
  FIX::TradeHandlingInstr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeHandlingInstr *)new FIX::TradeHandlingInstr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeHandlingInstr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeHandlingInstr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeHandlingInstr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeHandlingInstr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeHandlingInstr";
  FIX::TradeHandlingInstr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TradeHandlingInstr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TradeHandlingInstr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TradeHandlingInstr *)new FIX::TradeHandlingInstr((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeHandlingInstr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeHandlingInstr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeHandlingInstr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeHandlingInstr.new", 
    "    TradeHandlingInstr.new()\n"
    "    TradeHandlingInstr.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeHandlingInstr(FIX::TradeHandlingInstr *arg1) {
    delete arg1;
}

swig_class SwigClassCashSettlAgentCode;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentCode";
  FIX::CashSettlAgentCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashSettlAgentCode *)new FIX::CashSettlAgentCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashSettlAgentCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashSettlAgentCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashSettlAgentCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashSettlAgentCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentCode";
  FIX::CashSettlAgentCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashSettlAgentCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashSettlAgentCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashSettlAgentCode *)new FIX::CashSettlAgentCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashSettlAgentCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashSettlAgentCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashSettlAgentCode.new", 
    "    CashSettlAgentCode.new()\n"
    "    CashSettlAgentCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentCode(FIX::CashSettlAgentCode *arg1) {
    delete arg1;
}

swig_class SwigClassLegPriceType;

SWIGINTERN VALUE
_wrap_new_LegPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegPriceType";
  FIX::LegPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegPriceType *)new FIX::LegPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceType";
  FIX::LegPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegPriceType *)new FIX::LegPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegPriceType.new", 
    "    LegPriceType.new()\n"
    "    LegPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPriceType(FIX::LegPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedListExecInstLen;

SWIGINTERN VALUE
_wrap_new_EncodedListExecInstLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInstLen";
  FIX::EncodedListExecInstLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedListExecInstLen *)new FIX::EncodedListExecInstLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedListExecInstLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedListExecInstLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedListExecInstLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedListExecInstLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInstLen";
  FIX::EncodedListExecInstLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedListExecInstLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedListExecInstLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedListExecInstLen *)new FIX::EncodedListExecInstLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedListExecInstLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedListExecInstLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListExecInstLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedListExecInstLen.new", 
    "    EncodedListExecInstLen.new()\n"
    "    EncodedListExecInstLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListExecInstLen(FIX::EncodedListExecInstLen *arg1) {
    delete arg1;
}

swig_class SwigClassTradSesMethod;

SWIGINTERN VALUE
_wrap_new_TradSesMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradSesMethod";
  FIX::TradSesMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradSesMethod *)new FIX::TradSesMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradSesMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradSesMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradSesMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradSesMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesMethod";
  FIX::TradSesMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TradSesMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TradSesMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TradSesMethod *)new FIX::TradSesMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradSesMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradSesMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradSesMethod.new", 
    "    TradSesMethod.new()\n"
    "    TradSesMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesMethod(FIX::TradSesMethod *arg1) {
    delete arg1;
}

swig_class SwigClassAgreementID;

SWIGINTERN VALUE
_wrap_new_AgreementID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AgreementID";
  FIX::AgreementID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AgreementID *)new FIX::AgreementID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AgreementID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AgreementID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AgreementID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AgreementID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementID";
  FIX::AgreementID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::AgreementID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::AgreementID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::AgreementID *)new FIX::AgreementID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AgreementID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AgreementID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AgreementID.new", 
    "    AgreementID.new()\n"
    "    AgreementID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementID(FIX::AgreementID *arg1) {
    delete arg1;
}

swig_class SwigClassCashDistribCurr;

SWIGINTERN VALUE
_wrap_new_CashDistribCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashDistribCurr";
  FIX::CashDistribCurr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashDistribCurr *)new FIX::CashDistribCurr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashDistribCurr_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashDistribCurr_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashDistribCurr);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashDistribCurr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribCurr";
  FIX::CashDistribCurr *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::CashDistribCurr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::CashDistribCurr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::CashDistribCurr *)new FIX::CashDistribCurr((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashDistribCurr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashDistribCurr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribCurr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashDistribCurr.new", 
    "    CashDistribCurr.new()\n"
    "    CashDistribCurr.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribCurr(FIX::CashDistribCurr *arg1) {
    delete arg1;
}

swig_class SwigClassBidPx;

SWIGINTERN VALUE
_wrap_new_BidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidPx";
  FIX::BidPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidPx *)new FIX::BidPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidPx";
  FIX::BidPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::BidPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::BidPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::BidPx *)new FIX::BidPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidPx.new", 
    "    BidPx.new()\n"
    "    BidPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidPx(FIX::BidPx *arg1) {
    delete arg1;
}

swig_class SwigClassTradeType;

SWIGINTERN VALUE
_wrap_new_TradeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeType";
  FIX::TradeType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeType *)new FIX::TradeType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeType";
  FIX::TradeType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::TradeType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::TradeType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::TradeType *)new FIX::TradeType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeType.new", 
    "    TradeType.new()\n"
    "    TradeType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeType(FIX::TradeType *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDescLen";
  FIX::EncodedSecurityDescLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedSecurityDescLen *)new FIX::EncodedSecurityDescLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedSecurityDescLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedSecurityDescLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedSecurityDescLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedSecurityDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDescLen";
  FIX::EncodedSecurityDescLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedSecurityDescLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedSecurityDescLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedSecurityDescLen *)new FIX::EncodedSecurityDescLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSecurityDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSecurityDescLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedSecurityDescLen.new", 
    "    EncodedSecurityDescLen.new()\n"
    "    EncodedSecurityDescLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityDescLen(FIX::EncodedSecurityDescLen *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventCondition;

SWIGINTERN VALUE
_wrap_new_ComplexEventCondition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventCondition";
  FIX::ComplexEventCondition *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventCondition *)new FIX::ComplexEventCondition();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventCondition_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventCondition_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventCondition);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventCondition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventCondition";
  FIX::ComplexEventCondition *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ComplexEventCondition", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ComplexEventCondition", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ComplexEventCondition *)new FIX::ComplexEventCondition((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventCondition(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventCondition__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventCondition__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventCondition.new", 
    "    ComplexEventCondition.new()\n"
    "    ComplexEventCondition.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventCondition(FIX::ComplexEventCondition *arg1) {
    delete arg1;
}

swig_class SwigClassEncryptedPasswordMethod;

SWIGINTERN VALUE
_wrap_new_EncryptedPasswordMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordMethod";
  FIX::EncryptedPasswordMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncryptedPasswordMethod *)new FIX::EncryptedPasswordMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncryptedPasswordMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncryptedPasswordMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncryptedPasswordMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncryptedPasswordMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordMethod";
  FIX::EncryptedPasswordMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::EncryptedPasswordMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::EncryptedPasswordMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::EncryptedPasswordMethod *)new FIX::EncryptedPasswordMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncryptedPasswordMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncryptedPasswordMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedPasswordMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncryptedPasswordMethod.new", 
    "    EncryptedPasswordMethod.new()\n"
    "    EncryptedPasswordMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedPasswordMethod(FIX::EncryptedPasswordMethod *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityAltID;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltID";
  FIX::DerivativeSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityAltID *)new FIX::DerivativeSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltID";
  FIX::DerivativeSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityAltID *)new FIX::DerivativeSecurityAltID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityAltID.new", 
    "    DerivativeSecurityAltID.new()\n"
    "    DerivativeSecurityAltID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityAltID(FIX::DerivativeSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoAccQuotes;

SWIGINTERN VALUE
_wrap_new_TotNoAccQuotes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoAccQuotes";
  FIX::TotNoAccQuotes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoAccQuotes *)new FIX::TotNoAccQuotes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoAccQuotes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoAccQuotes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoAccQuotes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoAccQuotes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoAccQuotes";
  FIX::TotNoAccQuotes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoAccQuotes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoAccQuotes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoAccQuotes *)new FIX::TotNoAccQuotes((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoAccQuotes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoAccQuotes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoAccQuotes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoAccQuotes.new", 
    "    TotNoAccQuotes.new()\n"
    "    TotNoAccQuotes.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoAccQuotes(FIX::TotNoAccQuotes *arg1) {
    delete arg1;
}

swig_class SwigClassTimeBracket;

SWIGINTERN VALUE
_wrap_new_TimeBracket__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TimeBracket";
  FIX::TimeBracket *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TimeBracket *)new FIX::TimeBracket();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TimeBracket_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TimeBracket_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TimeBracket);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TimeBracket__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeBracket";
  FIX::TimeBracket *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TimeBracket", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TimeBracket", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TimeBracket *)new FIX::TimeBracket((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TimeBracket(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TimeBracket__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeBracket__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TimeBracket.new", 
    "    TimeBracket.new()\n"
    "    TimeBracket.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeBracket(FIX::TimeBracket *arg1) {
    delete arg1;
}

swig_class SwigClassNoAllocs;

SWIGINTERN VALUE
_wrap_new_NoAllocs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoAllocs";
  FIX::NoAllocs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoAllocs *)new FIX::NoAllocs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoAllocs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoAllocs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoAllocs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoAllocs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAllocs";
  FIX::NoAllocs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoAllocs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoAllocs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoAllocs *)new FIX::NoAllocs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoAllocs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoAllocs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAllocs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoAllocs.new", 
    "    NoAllocs.new()\n"
    "    NoAllocs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAllocs(FIX::NoAllocs *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingProduct;

SWIGINTERN VALUE
_wrap_new_UnderlyingProduct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingProduct";
  FIX::UnderlyingProduct *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingProduct *)new FIX::UnderlyingProduct();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingProduct_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingProduct_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingProduct);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingProduct__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingProduct";
  FIX::UnderlyingProduct *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingProduct", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingProduct", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingProduct *)new FIX::UnderlyingProduct((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingProduct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingProduct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingProduct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingProduct.new", 
    "    UnderlyingProduct.new()\n"
    "    UnderlyingProduct.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingProduct(FIX::UnderlyingProduct *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkCurveName;

SWIGINTERN VALUE
_wrap_new_BenchmarkCurveName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveName";
  FIX::BenchmarkCurveName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkCurveName *)new FIX::BenchmarkCurveName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkCurveName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkCurveName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkCurveName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkCurveName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveName";
  FIX::BenchmarkCurveName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::BenchmarkCurveName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::BenchmarkCurveName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::BenchmarkCurveName *)new FIX::BenchmarkCurveName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkCurveName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkCurveName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkCurveName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkCurveName.new", 
    "    BenchmarkCurveName.new()\n"
    "    BenchmarkCurveName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkCurveName(FIX::BenchmarkCurveName *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSymbolSfx;

SWIGINTERN VALUE
_wrap_new_UnderlyingSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbolSfx";
  FIX::UnderlyingSymbolSfx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSymbolSfx *)new FIX::UnderlyingSymbolSfx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSymbolSfx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSymbolSfx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSymbolSfx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSymbolSfx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbolSfx";
  FIX::UnderlyingSymbolSfx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSymbolSfx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSymbolSfx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSymbolSfx *)new FIX::UnderlyingSymbolSfx((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSymbolSfx.new", 
    "    UnderlyingSymbolSfx.new()\n"
    "    UnderlyingSymbolSfx.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSymbolSfx(FIX::UnderlyingSymbolSfx *arg1) {
    delete arg1;
}

swig_class SwigClassStrikePriceBoundaryPrecision;

SWIGINTERN VALUE
_wrap_new_StrikePriceBoundaryPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryPrecision";
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrikePriceBoundaryPrecision *)new FIX::StrikePriceBoundaryPrecision();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrikePriceBoundaryPrecision_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrikePriceBoundaryPrecision_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrikePriceBoundaryPrecision__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryPrecision";
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::StrikePriceBoundaryPrecision", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::StrikePriceBoundaryPrecision", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::StrikePriceBoundaryPrecision *)new FIX::StrikePriceBoundaryPrecision((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrikePriceBoundaryPrecision(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrikePriceBoundaryPrecision__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePriceBoundaryPrecision__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrikePriceBoundaryPrecision.new", 
    "    StrikePriceBoundaryPrecision.new()\n"
    "    StrikePriceBoundaryPrecision.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePriceBoundaryPrecision(FIX::StrikePriceBoundaryPrecision *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteSetID;

SWIGINTERN VALUE
_wrap_new_QuoteSetID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetID";
  FIX::QuoteSetID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteSetID *)new FIX::QuoteSetID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteSetID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteSetID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteSetID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteSetID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetID";
  FIX::QuoteSetID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteSetID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteSetID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteSetID *)new FIX::QuoteSetID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteSetID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteSetID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteSetID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteSetID.new", 
    "    QuoteSetID.new()\n"
    "    QuoteSetID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteSetID(FIX::QuoteSetID *arg1) {
    delete arg1;
}

swig_class SwigClassCashMargin;

SWIGINTERN VALUE
_wrap_new_CashMargin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashMargin";
  FIX::CashMargin *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashMargin *)new FIX::CashMargin();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashMargin_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashMargin_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashMargin);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashMargin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashMargin";
  FIX::CashMargin *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::CashMargin", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::CashMargin", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::CashMargin *)new FIX::CashMargin((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashMargin(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashMargin__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashMargin__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashMargin.new", 
    "    CashMargin.new()\n"
    "    CashMargin.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashMargin(FIX::CashMargin *arg1) {
    delete arg1;
}

swig_class SwigClassSettlObligTransType;

SWIGINTERN VALUE
_wrap_new_SettlObligTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlObligTransType";
  FIX::SettlObligTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlObligTransType *)new FIX::SettlObligTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlObligTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlObligTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlObligTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlObligTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligTransType";
  FIX::SettlObligTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlObligTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlObligTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlObligTransType *)new FIX::SettlObligTransType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlObligTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlObligTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlObligTransType.new", 
    "    SettlObligTransType.new()\n"
    "    SettlObligTransType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligTransType(FIX::SettlObligTransType *arg1) {
    delete arg1;
}

swig_class SwigClassLegNumber;

SWIGINTERN VALUE
_wrap_new_LegNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegNumber";
  FIX::LegNumber *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegNumber *)new FIX::LegNumber();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegNumber_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegNumber_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegNumber);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegNumber__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegNumber";
  FIX::LegNumber *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::LegNumber", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::LegNumber", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegNumber *)new FIX::LegNumber((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegNumber(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegNumber__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegNumber__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegNumber.new", 
    "    LegNumber.new()\n"
    "    LegNumber.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegNumber(FIX::LegNumber *arg1) {
    delete arg1;
}

swig_class SwigClassDeskOrderHandlingInst;

SWIGINTERN VALUE
_wrap_new_DeskOrderHandlingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeskOrderHandlingInst";
  FIX::DeskOrderHandlingInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeskOrderHandlingInst *)new FIX::DeskOrderHandlingInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeskOrderHandlingInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeskOrderHandlingInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeskOrderHandlingInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskOrderHandlingInst";
  FIX::DeskOrderHandlingInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLESTRINGVALUE const &","FIX::DeskOrderHandlingInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLESTRINGVALUE const &","FIX::DeskOrderHandlingInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  result = (FIX::DeskOrderHandlingInst *)new FIX::DeskOrderHandlingInst((FIX::MULTIPLESTRINGVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeskOrderHandlingInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeskOrderHandlingInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskOrderHandlingInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeskOrderHandlingInst.new", 
    "    DeskOrderHandlingInst.new()\n"
    "    DeskOrderHandlingInst.new(FIX::MULTIPLESTRINGVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskOrderHandlingInst(FIX::DeskOrderHandlingInst *arg1) {
    delete arg1;
}

swig_class SwigClassSettlPartyIDSource;

SWIGINTERN VALUE
_wrap_new_SettlPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyIDSource";
  FIX::SettlPartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlPartyIDSource *)new FIX::SettlPartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlPartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlPartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlPartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyIDSource";
  FIX::SettlPartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlPartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlPartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlPartyIDSource *)new FIX::SettlPartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlPartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlPartyIDSource.new", 
    "    SettlPartyIDSource.new()\n"
    "    SettlPartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartyIDSource(FIX::SettlPartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassPriorSettlPrice;

SWIGINTERN VALUE
_wrap_new_PriorSettlPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriorSettlPrice";
  FIX::PriorSettlPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriorSettlPrice *)new FIX::PriorSettlPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriorSettlPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriorSettlPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriorSettlPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriorSettlPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorSettlPrice";
  FIX::PriorSettlPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::PriorSettlPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::PriorSettlPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::PriorSettlPrice *)new FIX::PriorSettlPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriorSettlPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriorSettlPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriorSettlPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriorSettlPrice.new", 
    "    PriorSettlPrice.new()\n"
    "    PriorSettlPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriorSettlPrice(FIX::PriorSettlPrice *arg1) {
    delete arg1;
}

swig_class SwigClassNotAffOrigClOrdID;

SWIGINTERN VALUE
_wrap_new_NotAffOrigClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NotAffOrigClOrdID";
  FIX::NotAffOrigClOrdID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NotAffOrigClOrdID *)new FIX::NotAffOrigClOrdID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NotAffOrigClOrdID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NotAffOrigClOrdID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NotAffOrigClOrdID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NotAffOrigClOrdID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotAffOrigClOrdID";
  FIX::NotAffOrigClOrdID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::NotAffOrigClOrdID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::NotAffOrigClOrdID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NotAffOrigClOrdID *)new FIX::NotAffOrigClOrdID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NotAffOrigClOrdID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NotAffOrigClOrdID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotAffOrigClOrdID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NotAffOrigClOrdID.new", 
    "    NotAffOrigClOrdID.new()\n"
    "    NotAffOrigClOrdID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NotAffOrigClOrdID(FIX::NotAffOrigClOrdID *arg1) {
    delete arg1;
}

swig_class SwigClassTradingSessionDesc;

SWIGINTERN VALUE
_wrap_new_TradingSessionDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionDesc";
  FIX::TradingSessionDesc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradingSessionDesc *)new FIX::TradingSessionDesc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradingSessionDesc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradingSessionDesc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradingSessionDesc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradingSessionDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionDesc";
  FIX::TradingSessionDesc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TradingSessionDesc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TradingSessionDesc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TradingSessionDesc *)new FIX::TradingSessionDesc((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradingSessionDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradingSessionDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingSessionDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradingSessionDesc.new", 
    "    TradingSessionDesc.new()\n"
    "    TradingSessionDesc.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingSessionDesc(FIX::TradingSessionDesc *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeFloorPrice;

SWIGINTERN VALUE
_wrap_new_DerivativeFloorPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFloorPrice";
  FIX::DerivativeFloorPrice *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeFloorPrice *)new FIX::DerivativeFloorPrice();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeFloorPrice_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeFloorPrice_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeFloorPrice);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeFloorPrice__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFloorPrice";
  FIX::DerivativeFloorPrice *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::DerivativeFloorPrice", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::DerivativeFloorPrice", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::DerivativeFloorPrice *)new FIX::DerivativeFloorPrice((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeFloorPrice(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeFloorPrice__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeFloorPrice__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeFloorPrice.new", 
    "    DerivativeFloorPrice.new()\n"
    "    DerivativeFloorPrice.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeFloorPrice(FIX::DerivativeFloorPrice *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSymbol;

SWIGINTERN VALUE
_wrap_new_DerivativeSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbol";
  FIX::DerivativeSymbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSymbol *)new FIX::DerivativeSymbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSymbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSymbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSymbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbol";
  FIX::DerivativeSymbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSymbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSymbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSymbol *)new FIX::DerivativeSymbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSymbol.new", 
    "    DerivativeSymbol.new()\n"
    "    DerivativeSymbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSymbol(FIX::DerivativeSymbol *arg1) {
    delete arg1;
}

swig_class SwigClassRiskFreeRate;

SWIGINTERN VALUE
_wrap_new_RiskFreeRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RiskFreeRate";
  FIX::RiskFreeRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RiskFreeRate *)new FIX::RiskFreeRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RiskFreeRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RiskFreeRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RiskFreeRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RiskFreeRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskFreeRate";
  FIX::RiskFreeRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::RiskFreeRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::RiskFreeRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::RiskFreeRate *)new FIX::RiskFreeRate((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskFreeRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskFreeRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskFreeRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RiskFreeRate.new", 
    "    RiskFreeRate.new()\n"
    "    RiskFreeRate.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskFreeRate(FIX::RiskFreeRate *arg1) {
    delete arg1;
}

swig_class SwigClassPosTransType;

SWIGINTERN VALUE
_wrap_new_PosTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosTransType";
  FIX::PosTransType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosTransType *)new FIX::PosTransType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosTransType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosTransType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosTransType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosTransType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosTransType";
  FIX::PosTransType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosTransType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosTransType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosTransType *)new FIX::PosTransType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosTransType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosTransType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosTransType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosTransType.new", 
    "    PosTransType.new()\n"
    "    PosTransType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosTransType(FIX::PosTransType *arg1) {
    delete arg1;
}

swig_class SwigClassMsgSeqNum;

SWIGINTERN VALUE
_wrap_new_MsgSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MsgSeqNum";
  FIX::MsgSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MsgSeqNum *)new FIX::MsgSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MsgSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MsgSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MsgSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MsgSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgSeqNum";
  FIX::MsgSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::MsgSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::MsgSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::MsgSeqNum *)new FIX::MsgSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MsgSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MsgSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MsgSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MsgSeqNum.new", 
    "    MsgSeqNum.new()\n"
    "    MsgSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MsgSeqNum(FIX::MsgSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassSignature;

SWIGINTERN VALUE
_wrap_new_Signature__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Signature";
  FIX::Signature *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Signature *)new FIX::Signature();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Signature_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Signature_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Signature);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Signature__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Signature";
  FIX::Signature *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::Signature", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::Signature", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::Signature *)new FIX::Signature((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Signature(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Signature__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Signature__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Signature.new", 
    "    Signature.new()\n"
    "    Signature.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Signature(FIX::Signature *arg1) {
    delete arg1;
}

swig_class SwigClassSeniority;

SWIGINTERN VALUE
_wrap_new_Seniority__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Seniority";
  FIX::Seniority *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Seniority *)new FIX::Seniority();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Seniority_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Seniority_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Seniority);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Seniority__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Seniority";
  FIX::Seniority *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Seniority", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Seniority", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Seniority *)new FIX::Seniority((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Seniority(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Seniority__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Seniority__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Seniority.new", 
    "    Seniority.new()\n"
    "    Seniority.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Seniority(FIX::Seniority *arg1) {
    delete arg1;
}

swig_class SwigClassNoRateSources;

SWIGINTERN VALUE
_wrap_new_NoRateSources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRateSources";
  FIX::NoRateSources *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRateSources *)new FIX::NoRateSources();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRateSources_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRateSources_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRateSources);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRateSources__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRateSources";
  FIX::NoRateSources *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoRateSources", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoRateSources", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRateSources *)new FIX::NoRateSources((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRateSources(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRateSources__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRateSources__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRateSources.new", 
    "    NoRateSources.new()\n"
    "    NoRateSources.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRateSources(FIX::NoRateSources *arg1) {
    delete arg1;
}

swig_class SwigClassPriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_PriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasureQty";
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriceUnitOfMeasureQty *)new FIX::PriceUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriceUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriceUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriceUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriceUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasureQty";
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::PriceUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::PriceUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::PriceUnitOfMeasureQty *)new FIX::PriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriceUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriceUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriceUnitOfMeasureQty.new", 
    "    PriceUnitOfMeasureQty.new()\n"
    "    PriceUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceUnitOfMeasureQty(FIX::PriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassCollAsgnRefID;

SWIGINTERN VALUE
_wrap_new_CollAsgnRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRefID";
  FIX::CollAsgnRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollAsgnRefID *)new FIX::CollAsgnRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollAsgnRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollAsgnRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollAsgnRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollAsgnRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRefID";
  FIX::CollAsgnRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CollAsgnRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CollAsgnRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CollAsgnRefID *)new FIX::CollAsgnRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollAsgnRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollAsgnRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollAsgnRefID.new", 
    "    CollAsgnRefID.new()\n"
    "    CollAsgnRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnRefID(FIX::CollAsgnRefID *arg1) {
    delete arg1;
}

swig_class SwigClassBuyVolume;

SWIGINTERN VALUE
_wrap_new_BuyVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BuyVolume";
  FIX::BuyVolume *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BuyVolume *)new FIX::BuyVolume();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BuyVolume_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BuyVolume_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BuyVolume);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BuyVolume__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BuyVolume";
  FIX::BuyVolume *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::BuyVolume", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::BuyVolume", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::BuyVolume *)new FIX::BuyVolume((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BuyVolume(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BuyVolume__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BuyVolume__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BuyVolume.new", 
    "    BuyVolume.new()\n"
    "    BuyVolume.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BuyVolume(FIX::BuyVolume *arg1) {
    delete arg1;
}

swig_class SwigClassSettlCurrFxRateCalc;

SWIGINTERN VALUE
_wrap_new_SettlCurrFxRateCalc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRateCalc";
  FIX::SettlCurrFxRateCalc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlCurrFxRateCalc *)new FIX::SettlCurrFxRateCalc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlCurrFxRateCalc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlCurrFxRateCalc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlCurrFxRateCalc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlCurrFxRateCalc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRateCalc";
  FIX::SettlCurrFxRateCalc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::SettlCurrFxRateCalc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::SettlCurrFxRateCalc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::SettlCurrFxRateCalc *)new FIX::SettlCurrFxRateCalc((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlCurrFxRateCalc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlCurrFxRateCalc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrFxRateCalc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlCurrFxRateCalc.new", 
    "    SettlCurrFxRateCalc.new()\n"
    "    SettlCurrFxRateCalc.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrFxRateCalc(FIX::SettlCurrFxRateCalc *arg1) {
    delete arg1;
}

swig_class SwigClassPosMaintStatus;

SWIGINTERN VALUE
_wrap_new_PosMaintStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosMaintStatus";
  FIX::PosMaintStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosMaintStatus *)new FIX::PosMaintStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosMaintStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosMaintStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosMaintStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosMaintStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintStatus";
  FIX::PosMaintStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosMaintStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosMaintStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosMaintStatus *)new FIX::PosMaintStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosMaintStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosMaintStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosMaintStatus.new", 
    "    PosMaintStatus.new()\n"
    "    PosMaintStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintStatus(FIX::PosMaintStatus *arg1) {
    delete arg1;
}

swig_class SwigClassPriorSpreadIndicator;

SWIGINTERN VALUE
_wrap_new_PriorSpreadIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriorSpreadIndicator";
  FIX::PriorSpreadIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriorSpreadIndicator *)new FIX::PriorSpreadIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriorSpreadIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriorSpreadIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriorSpreadIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriorSpreadIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorSpreadIndicator";
  FIX::PriorSpreadIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::PriorSpreadIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::PriorSpreadIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::PriorSpreadIndicator *)new FIX::PriorSpreadIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriorSpreadIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriorSpreadIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriorSpreadIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriorSpreadIndicator.new", 
    "    PriorSpreadIndicator.new()\n"
    "    PriorSpreadIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriorSpreadIndicator(FIX::PriorSpreadIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmark;

SWIGINTERN VALUE
_wrap_new_Benchmark__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Benchmark";
  FIX::Benchmark *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Benchmark *)new FIX::Benchmark();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Benchmark_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Benchmark_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Benchmark);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Benchmark__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Benchmark";
  FIX::Benchmark *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Benchmark", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Benchmark", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Benchmark *)new FIX::Benchmark((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Benchmark(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Benchmark__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Benchmark__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Benchmark.new", 
    "    Benchmark.new()\n"
    "    Benchmark.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Benchmark(FIX::Benchmark *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityMonthYearFormat;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearFormat__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearFormat";
  FIX::MaturityMonthYearFormat *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityMonthYearFormat *)new FIX::MaturityMonthYearFormat();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityMonthYearFormat_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityMonthYearFormat_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityMonthYearFormat);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearFormat__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearFormat";
  FIX::MaturityMonthYearFormat *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::MaturityMonthYearFormat", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::MaturityMonthYearFormat", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::MaturityMonthYearFormat *)new FIX::MaturityMonthYearFormat((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityMonthYearFormat(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityMonthYearFormat__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYearFormat__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityMonthYearFormat.new", 
    "    MaturityMonthYearFormat.new()\n"
    "    MaturityMonthYearFormat.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYearFormat(FIX::MaturityMonthYearFormat *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingTradingSessionID;

SWIGINTERN VALUE
_wrap_new_UnderlyingTradingSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionID";
  FIX::UnderlyingTradingSessionID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingTradingSessionID *)new FIX::UnderlyingTradingSessionID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingTradingSessionID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingTradingSessionID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingTradingSessionID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingTradingSessionID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionID";
  FIX::UnderlyingTradingSessionID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingTradingSessionID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingTradingSessionID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingTradingSessionID *)new FIX::UnderlyingTradingSessionID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingTradingSessionID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingTradingSessionID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingTradingSessionID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingTradingSessionID.new", 
    "    UnderlyingTradingSessionID.new()\n"
    "    UnderlyingTradingSessionID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingTradingSessionID(FIX::UnderlyingTradingSessionID *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoRelatedSym;

SWIGINTERN VALUE
_wrap_new_TotNoRelatedSym__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoRelatedSym";
  FIX::TotNoRelatedSym *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoRelatedSym *)new FIX::TotNoRelatedSym();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoRelatedSym_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoRelatedSym_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoRelatedSym);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoRelatedSym__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoRelatedSym";
  FIX::TotNoRelatedSym *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoRelatedSym", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoRelatedSym", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoRelatedSym *)new FIX::TotNoRelatedSym((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoRelatedSym(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoRelatedSym__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoRelatedSym__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoRelatedSym.new", 
    "    TotNoRelatedSym.new()\n"
    "    TotNoRelatedSym.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoRelatedSym(FIX::TotNoRelatedSym *arg1) {
    delete arg1;
}

swig_class SwigClassStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_StateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StateOrProvinceOfIssue";
  FIX::StateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StateOrProvinceOfIssue *)new FIX::StateOrProvinceOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StateOrProvinceOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StateOrProvinceOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StateOrProvinceOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StateOrProvinceOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StateOrProvinceOfIssue";
  FIX::StateOrProvinceOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StateOrProvinceOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StateOrProvinceOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StateOrProvinceOfIssue *)new FIX::StateOrProvinceOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StateOrProvinceOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StateOrProvinceOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StateOrProvinceOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StateOrProvinceOfIssue.new", 
    "    StateOrProvinceOfIssue.new()\n"
    "    StateOrProvinceOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StateOrProvinceOfIssue(FIX::StateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrRegistry;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrRegistry";
  FIX::DerivativeInstrRegistry *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrRegistry *)new FIX::DerivativeInstrRegistry();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrRegistry_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrRegistry_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrRegistry);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrRegistry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrRegistry";
  FIX::DerivativeInstrRegistry *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeInstrRegistry", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeInstrRegistry", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeInstrRegistry *)new FIX::DerivativeInstrRegistry((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrRegistry(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrRegistry__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrRegistry__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrRegistry.new", 
    "    DerivativeInstrRegistry.new()\n"
    "    DerivativeInstrRegistry.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrRegistry(FIX::DerivativeInstrRegistry *arg1) {
    delete arg1;
}

swig_class SwigClassLegBidForwardPoints;

SWIGINTERN VALUE
_wrap_new_LegBidForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegBidForwardPoints";
  FIX::LegBidForwardPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegBidForwardPoints *)new FIX::LegBidForwardPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegBidForwardPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegBidForwardPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegBidForwardPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegBidForwardPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBidForwardPoints";
  FIX::LegBidForwardPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::LegBidForwardPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::LegBidForwardPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::LegBidForwardPoints *)new FIX::LegBidForwardPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegBidForwardPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegBidForwardPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBidForwardPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegBidForwardPoints.new", 
    "    LegBidForwardPoints.new()\n"
    "    LegBidForwardPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBidForwardPoints(FIX::LegBidForwardPoints *arg1) {
    delete arg1;
}

swig_class SwigClassManualOrderIndicator;

SWIGINTERN VALUE
_wrap_new_ManualOrderIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ManualOrderIndicator";
  FIX::ManualOrderIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ManualOrderIndicator *)new FIX::ManualOrderIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ManualOrderIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ManualOrderIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ManualOrderIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ManualOrderIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ManualOrderIndicator";
  FIX::ManualOrderIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ManualOrderIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ManualOrderIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ManualOrderIndicator *)new FIX::ManualOrderIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ManualOrderIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ManualOrderIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ManualOrderIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ManualOrderIndicator.new", 
    "    ManualOrderIndicator.new()\n"
    "    ManualOrderIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ManualOrderIndicator(FIX::ManualOrderIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassNetMoney;

SWIGINTERN VALUE
_wrap_new_NetMoney__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetMoney";
  FIX::NetMoney *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetMoney *)new FIX::NetMoney();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetMoney_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetMoney_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetMoney);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetMoney__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetMoney";
  FIX::NetMoney *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::NetMoney", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::NetMoney", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::NetMoney *)new FIX::NetMoney((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetMoney(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetMoney__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetMoney__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetMoney.new", 
    "    NetMoney.new()\n"
    "    NetMoney.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetMoney(FIX::NetMoney *arg1) {
    delete arg1;
}

swig_class SwigClassLegalConfirm;

SWIGINTERN VALUE
_wrap_new_LegalConfirm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegalConfirm";
  FIX::LegalConfirm *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegalConfirm *)new FIX::LegalConfirm();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegalConfirm_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegalConfirm_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegalConfirm);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegalConfirm__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegalConfirm";
  FIX::LegalConfirm *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::LegalConfirm", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::LegalConfirm", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::LegalConfirm *)new FIX::LegalConfirm((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegalConfirm(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegalConfirm__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegalConfirm__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegalConfirm.new", 
    "    LegalConfirm.new()\n"
    "    LegalConfirm.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegalConfirm(FIX::LegalConfirm *arg1) {
    delete arg1;
}

swig_class SwigClassCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_CountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CountryOfIssue";
  FIX::CountryOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CountryOfIssue *)new FIX::CountryOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CountryOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CountryOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CountryOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CountryOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CountryOfIssue";
  FIX::CountryOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__COUNTRY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::COUNTRY const &","FIX::CountryOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::COUNTRY const &","FIX::CountryOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  result = (FIX::CountryOfIssue *)new FIX::CountryOfIssue((FIX::COUNTRY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CountryOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CountryOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CountryOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CountryOfIssue.new", 
    "    CountryOfIssue.new()\n"
    "    CountryOfIssue.new(FIX::COUNTRY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CountryOfIssue(FIX::CountryOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassApplReportType;

SWIGINTERN VALUE
_wrap_new_ApplReportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplReportType";
  FIX::ApplReportType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplReportType *)new FIX::ApplReportType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplReportType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplReportType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplReportType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplReportType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReportType";
  FIX::ApplReportType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplReportType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplReportType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplReportType *)new FIX::ApplReportType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplReportType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplReportType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReportType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplReportType.new", 
    "    ApplReportType.new()\n"
    "    ApplReportType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReportType(FIX::ApplReportType *arg1) {
    delete arg1;
}

swig_class SwigClassRootPartyID;

SWIGINTERN VALUE
_wrap_new_RootPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RootPartyID";
  FIX::RootPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RootPartyID *)new FIX::RootPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RootPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RootPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RootPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RootPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyID";
  FIX::RootPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::RootPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::RootPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::RootPartyID *)new FIX::RootPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RootPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RootPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RootPartyID.new", 
    "    RootPartyID.new()\n"
    "    RootPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartyID(FIX::RootPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingQty";
  FIX::UnderlyingQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingQty *)new FIX::UnderlyingQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingQty";
  FIX::UnderlyingQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::UnderlyingQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::UnderlyingQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::UnderlyingQty *)new FIX::UnderlyingQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingQty.new", 
    "    UnderlyingQty.new()\n"
    "    UnderlyingQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingQty(FIX::UnderlyingQty *arg1) {
    delete arg1;
}

swig_class SwigClassApplQueueDepth;

SWIGINTERN VALUE
_wrap_new_ApplQueueDepth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueDepth";
  FIX::ApplQueueDepth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplQueueDepth *)new FIX::ApplQueueDepth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplQueueDepth_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplQueueDepth_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplQueueDepth);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplQueueDepth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueDepth";
  FIX::ApplQueueDepth *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplQueueDepth", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplQueueDepth", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplQueueDepth *)new FIX::ApplQueueDepth((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplQueueDepth(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplQueueDepth__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueDepth__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplQueueDepth.new", 
    "    ApplQueueDepth.new()\n"
    "    ApplQueueDepth.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueDepth(FIX::ApplQueueDepth *arg1) {
    delete arg1;
}

swig_class SwigClassStopPx;

SWIGINTERN VALUE
_wrap_new_StopPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StopPx";
  FIX::StopPx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StopPx *)new FIX::StopPx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StopPx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StopPx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StopPx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StopPx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StopPx";
  FIX::StopPx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::StopPx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::StopPx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::StopPx *)new FIX::StopPx((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StopPx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StopPx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StopPx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StopPx.new", 
    "    StopPx.new()\n"
    "    StopPx.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StopPx(FIX::StopPx *arg1) {
    delete arg1;
}

swig_class SwigClassReportToExch;

SWIGINTERN VALUE
_wrap_new_ReportToExch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ReportToExch";
  FIX::ReportToExch *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ReportToExch *)new FIX::ReportToExch();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ReportToExch_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ReportToExch_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ReportToExch);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ReportToExch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportToExch";
  FIX::ReportToExch *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ReportToExch", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ReportToExch", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ReportToExch *)new FIX::ReportToExch((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ReportToExch(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ReportToExch__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReportToExch__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ReportToExch.new", 
    "    ReportToExch.new()\n"
    "    ReportToExch.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ReportToExch(FIX::ReportToExch *arg1) {
    delete arg1;
}

swig_class SwigClassContraryInstructionIndicator;

SWIGINTERN VALUE
_wrap_new_ContraryInstructionIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContraryInstructionIndicator";
  FIX::ContraryInstructionIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContraryInstructionIndicator *)new FIX::ContraryInstructionIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContraryInstructionIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContraryInstructionIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContraryInstructionIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContraryInstructionIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraryInstructionIndicator";
  FIX::ContraryInstructionIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ContraryInstructionIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ContraryInstructionIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ContraryInstructionIndicator *)new FIX::ContraryInstructionIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContraryInstructionIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContraryInstructionIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraryInstructionIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContraryInstructionIndicator.new", 
    "    ContraryInstructionIndicator.new()\n"
    "    ContraryInstructionIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraryInstructionIndicator(FIX::ContraryInstructionIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedListStatusTextLen;

SWIGINTERN VALUE
_wrap_new_EncodedListStatusTextLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusTextLen";
  FIX::EncodedListStatusTextLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedListStatusTextLen *)new FIX::EncodedListStatusTextLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedListStatusTextLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedListStatusTextLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedListStatusTextLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedListStatusTextLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusTextLen";
  FIX::EncodedListStatusTextLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedListStatusTextLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedListStatusTextLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedListStatusTextLen *)new FIX::EncodedListStatusTextLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedListStatusTextLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedListStatusTextLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListStatusTextLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedListStatusTextLen.new", 
    "    EncodedListStatusTextLen.new()\n"
    "    EncodedListStatusTextLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListStatusTextLen(FIX::EncodedListStatusTextLen *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityXMLSchema;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXMLSchema__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLSchema";
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityXMLSchema *)new FIX::DerivativeSecurityXMLSchema();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityXMLSchema_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityXMLSchema_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXMLSchema__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLSchema";
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityXMLSchema", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityXMLSchema", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityXMLSchema *)new FIX::DerivativeSecurityXMLSchema((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityXMLSchema(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityXMLSchema__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityXMLSchema__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityXMLSchema.new", 
    "    DerivativeSecurityXMLSchema.new()\n"
    "    DerivativeSecurityXMLSchema.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityXMLSchema(FIX::DerivativeSecurityXMLSchema *arg1) {
    delete arg1;
}

swig_class SwigClassNoRelatedSym;

SWIGINTERN VALUE
_wrap_new_NoRelatedSym__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedSym";
  FIX::NoRelatedSym *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRelatedSym *)new FIX::NoRelatedSym();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRelatedSym_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRelatedSym_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRelatedSym);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRelatedSym__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedSym";
  FIX::NoRelatedSym *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoRelatedSym", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoRelatedSym", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedSym *)new FIX::NoRelatedSym((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedSym(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedSym__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRelatedSym__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRelatedSym.new", 
    "    NoRelatedSym.new()\n"
    "    NoRelatedSym.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedSym(FIX::NoRelatedSym *arg1) {
    delete arg1;
}

swig_class SwigClassAllocRejCode;

SWIGINTERN VALUE
_wrap_new_AllocRejCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocRejCode";
  FIX::AllocRejCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocRejCode *)new FIX::AllocRejCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocRejCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocRejCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocRejCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocRejCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocRejCode";
  FIX::AllocRejCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocRejCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocRejCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocRejCode *)new FIX::AllocRejCode((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocRejCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocRejCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocRejCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocRejCode.new", 
    "    AllocRejCode.new()\n"
    "    AllocRejCode.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocRejCode(FIX::AllocRejCode *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityAltID;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltID";
  FIX::UnderlyingSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityAltID *)new FIX::UnderlyingSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltID";
  FIX::UnderlyingSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecurityAltID *)new FIX::UnderlyingSecurityAltID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityAltID.new", 
    "    UnderlyingSecurityAltID.new()\n"
    "    UnderlyingSecurityAltID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityAltID(FIX::UnderlyingSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassRefOrdIDReason;

SWIGINTERN VALUE
_wrap_new_RefOrdIDReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefOrdIDReason";
  FIX::RefOrdIDReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefOrdIDReason *)new FIX::RefOrdIDReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefOrdIDReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefOrdIDReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefOrdIDReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefOrdIDReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrdIDReason";
  FIX::RefOrdIDReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RefOrdIDReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RefOrdIDReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RefOrdIDReason *)new FIX::RefOrdIDReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefOrdIDReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefOrdIDReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefOrdIDReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefOrdIDReason.new", 
    "    RefOrdIDReason.new()\n"
    "    RefOrdIDReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefOrdIDReason(FIX::RefOrdIDReason *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyID";
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrumentPartyID *)new FIX::DerivativeInstrumentPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrumentPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrumentPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrumentPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyID";
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeInstrumentPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeInstrumentPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeInstrumentPartyID *)new FIX::DerivativeInstrumentPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrumentPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrumentPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrumentPartyID.new", 
    "    DerivativeInstrumentPartyID.new()\n"
    "    DerivativeInstrumentPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartyID(FIX::DerivativeInstrumentPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityXMLSchema;

SWIGINTERN VALUE
_wrap_new_SecurityXMLSchema__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLSchema";
  FIX::SecurityXMLSchema *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityXMLSchema *)new FIX::SecurityXMLSchema();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityXMLSchema_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityXMLSchema_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityXMLSchema);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityXMLSchema__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLSchema";
  FIX::SecurityXMLSchema *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityXMLSchema", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityXMLSchema", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityXMLSchema *)new FIX::SecurityXMLSchema((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityXMLSchema(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityXMLSchema__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityXMLSchema__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityXMLSchema.new", 
    "    SecurityXMLSchema.new()\n"
    "    SecurityXMLSchema.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityXMLSchema(FIX::SecurityXMLSchema *arg1) {
    delete arg1;
}

swig_class SwigClassRefOrderIDSource;

SWIGINTERN VALUE
_wrap_new_RefOrderIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefOrderIDSource";
  FIX::RefOrderIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefOrderIDSource *)new FIX::RefOrderIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefOrderIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefOrderIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefOrderIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefOrderIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrderIDSource";
  FIX::RefOrderIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::RefOrderIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::RefOrderIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RefOrderIDSource *)new FIX::RefOrderIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefOrderIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefOrderIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefOrderIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefOrderIDSource.new", 
    "    RefOrderIDSource.new()\n"
    "    RefOrderIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefOrderIDSource(FIX::RefOrderIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassNTPositionLimit;

SWIGINTERN VALUE
_wrap_new_NTPositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NTPositionLimit";
  FIX::NTPositionLimit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NTPositionLimit *)new FIX::NTPositionLimit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NTPositionLimit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NTPositionLimit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NTPositionLimit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NTPositionLimit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NTPositionLimit";
  FIX::NTPositionLimit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NTPositionLimit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NTPositionLimit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NTPositionLimit *)new FIX::NTPositionLimit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NTPositionLimit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NTPositionLimit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NTPositionLimit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NTPositionLimit.new", 
    "    NTPositionLimit.new()\n"
    "    NTPositionLimit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NTPositionLimit(FIX::NTPositionLimit *arg1) {
    delete arg1;
}

swig_class SwigClassEndAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_EndAccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EndAccruedInterestAmt";
  FIX::EndAccruedInterestAmt *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EndAccruedInterestAmt *)new FIX::EndAccruedInterestAmt();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EndAccruedInterestAmt_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EndAccruedInterestAmt_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EndAccruedInterestAmt);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EndAccruedInterestAmt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndAccruedInterestAmt";
  FIX::EndAccruedInterestAmt *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::EndAccruedInterestAmt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::EndAccruedInterestAmt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::EndAccruedInterestAmt *)new FIX::EndAccruedInterestAmt((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EndAccruedInterestAmt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EndAccruedInterestAmt__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndAccruedInterestAmt__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EndAccruedInterestAmt.new", 
    "    EndAccruedInterestAmt.new()\n"
    "    EndAccruedInterestAmt.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EndAccruedInterestAmt(FIX::EndAccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class SwigClassAccruedInterestRate;

SWIGINTERN VALUE
_wrap_new_AccruedInterestRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestRate";
  FIX::AccruedInterestRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AccruedInterestRate *)new FIX::AccruedInterestRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AccruedInterestRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AccruedInterestRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AccruedInterestRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AccruedInterestRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestRate";
  FIX::AccruedInterestRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::AccruedInterestRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::AccruedInterestRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::AccruedInterestRate *)new FIX::AccruedInterestRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AccruedInterestRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AccruedInterestRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccruedInterestRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AccruedInterestRate.new", 
    "    AccruedInterestRate.new()\n"
    "    AccruedInterestRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AccruedInterestRate(FIX::AccruedInterestRate *arg1) {
    delete arg1;
}

swig_class SwigClassLastCapacity;

SWIGINTERN VALUE
_wrap_new_LastCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastCapacity";
  FIX::LastCapacity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastCapacity *)new FIX::LastCapacity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastCapacity_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastCapacity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastCapacity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastCapacity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastCapacity";
  FIX::LastCapacity *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LastCapacity", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LastCapacity", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LastCapacity *)new FIX::LastCapacity((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastCapacity(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastCapacity__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastCapacity__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastCapacity.new", 
    "    LastCapacity.new()\n"
    "    LastCapacity.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastCapacity(FIX::LastCapacity *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubID";
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingInstrumentPartySubID *)new FIX::UnderlyingInstrumentPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingInstrumentPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingInstrumentPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubID";
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingInstrumentPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingInstrumentPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingInstrumentPartySubID *)new FIX::UnderlyingInstrumentPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingInstrumentPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingInstrumentPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingInstrumentPartySubID.new", 
    "    UnderlyingInstrumentPartySubID.new()\n"
    "    UnderlyingInstrumentPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartySubID(FIX::UnderlyingInstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassNoFills;

SWIGINTERN VALUE
_wrap_new_NoFills__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoFills";
  FIX::NoFills *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoFills *)new FIX::NoFills();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoFills_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoFills_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoFills);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoFills__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoFills";
  FIX::NoFills *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoFills", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoFills", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoFills *)new FIX::NoFills((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoFills(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoFills__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoFills__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoFills.new", 
    "    NoFills.new()\n"
    "    NoFills.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoFills(FIX::NoFills *arg1) {
    delete arg1;
}

swig_class SwigClassNoOrdTypeRules;

SWIGINTERN VALUE
_wrap_new_NoOrdTypeRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoOrdTypeRules";
  FIX::NoOrdTypeRules *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoOrdTypeRules *)new FIX::NoOrdTypeRules();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoOrdTypeRules_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoOrdTypeRules_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoOrdTypeRules);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoOrdTypeRules__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOrdTypeRules";
  FIX::NoOrdTypeRules *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoOrdTypeRules", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoOrdTypeRules", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoOrdTypeRules *)new FIX::NoOrdTypeRules((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoOrdTypeRules(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoOrdTypeRules__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOrdTypeRules__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoOrdTypeRules.new", 
    "    NoOrdTypeRules.new()\n"
    "    NoOrdTypeRules.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOrdTypeRules(FIX::NoOrdTypeRules *arg1) {
    delete arg1;
}

swig_class SwigClassInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_InstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyID";
  FIX::InstrumentPartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrumentPartyID *)new FIX::InstrumentPartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrumentPartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrumentPartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrumentPartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrumentPartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyID";
  FIX::InstrumentPartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::InstrumentPartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::InstrumentPartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::InstrumentPartyID *)new FIX::InstrumentPartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrumentPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrumentPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrumentPartyID.new", 
    "    InstrumentPartyID.new()\n"
    "    InstrumentPartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartyID(FIX::InstrumentPartyID *arg1) {
    delete arg1;
}

swig_class SwigClassMarginRatio;

SWIGINTERN VALUE
_wrap_new_MarginRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MarginRatio";
  FIX::MarginRatio *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MarginRatio *)new FIX::MarginRatio();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MarginRatio_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MarginRatio_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MarginRatio);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MarginRatio__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarginRatio";
  FIX::MarginRatio *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::MarginRatio", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::MarginRatio", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::MarginRatio *)new FIX::MarginRatio((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MarginRatio(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MarginRatio__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarginRatio__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MarginRatio.new", 
    "    MarginRatio.new()\n"
    "    MarginRatio.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MarginRatio(FIX::MarginRatio *arg1) {
    delete arg1;
}

swig_class SwigClassRefTagID;

SWIGINTERN VALUE
_wrap_new_RefTagID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::RefTagID";
  FIX::RefTagID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::RefTagID *)new FIX::RefTagID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RefTagID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RefTagID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__RefTagID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RefTagID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefTagID";
  FIX::RefTagID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::RefTagID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::RefTagID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RefTagID *)new FIX::RefTagID((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RefTagID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RefTagID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefTagID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "RefTagID.new", 
    "    RefTagID.new()\n"
    "    RefTagID.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_RefTagID(FIX::RefTagID *arg1) {
    delete arg1;
}

swig_class SwigClassNoRoutingIDs;

SWIGINTERN VALUE
_wrap_new_NoRoutingIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRoutingIDs";
  FIX::NoRoutingIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRoutingIDs *)new FIX::NoRoutingIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRoutingIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRoutingIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRoutingIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRoutingIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRoutingIDs";
  FIX::NoRoutingIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoRoutingIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoRoutingIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRoutingIDs *)new FIX::NoRoutingIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRoutingIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRoutingIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRoutingIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRoutingIDs.new", 
    "    NoRoutingIDs.new()\n"
    "    NoRoutingIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRoutingIDs(FIX::NoRoutingIDs *arg1) {
    delete arg1;
}

swig_class SwigClassCouponRate;

SWIGINTERN VALUE
_wrap_new_CouponRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CouponRate";
  FIX::CouponRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CouponRate *)new FIX::CouponRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CouponRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CouponRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CouponRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CouponRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CouponRate";
  FIX::CouponRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::CouponRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::CouponRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::CouponRate *)new FIX::CouponRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CouponRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CouponRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CouponRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CouponRate.new", 
    "    CouponRate.new()\n"
    "    CouponRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CouponRate(FIX::CouponRate *arg1) {
    delete arg1;
}

swig_class SwigClassNoApplIDs;

SWIGINTERN VALUE
_wrap_new_NoApplIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoApplIDs";
  FIX::NoApplIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoApplIDs *)new FIX::NoApplIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoApplIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoApplIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoApplIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoApplIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoApplIDs";
  FIX::NoApplIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoApplIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoApplIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoApplIDs *)new FIX::NoApplIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoApplIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoApplIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoApplIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoApplIDs.new", 
    "    NoApplIDs.new()\n"
    "    NoApplIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoApplIDs(FIX::NoApplIDs *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeContractSettlMonth;

SWIGINTERN VALUE
_wrap_new_DerivativeContractSettlMonth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractSettlMonth";
  FIX::DerivativeContractSettlMonth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeContractSettlMonth *)new FIX::DerivativeContractSettlMonth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeContractSettlMonth_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeContractSettlMonth_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeContractSettlMonth);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeContractSettlMonth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractSettlMonth";
  FIX::DerivativeContractSettlMonth *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MONTHYEAR const &","FIX::DerivativeContractSettlMonth", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MONTHYEAR const &","FIX::DerivativeContractSettlMonth", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::DerivativeContractSettlMonth *)new FIX::DerivativeContractSettlMonth((FIX::MONTHYEAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeContractSettlMonth(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeContractSettlMonth__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeContractSettlMonth__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeContractSettlMonth.new", 
    "    DerivativeContractSettlMonth.new()\n"
    "    DerivativeContractSettlMonth.new(FIX::MONTHYEAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeContractSettlMonth(FIX::DerivativeContractSettlMonth *arg1) {
    delete arg1;
}

swig_class SwigClassInstrAttribType;

SWIGINTERN VALUE
_wrap_new_InstrAttribType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribType";
  FIX::InstrAttribType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::InstrAttribType *)new FIX::InstrAttribType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstrAttribType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstrAttribType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__InstrAttribType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_InstrAttribType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribType";
  FIX::InstrAttribType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::InstrAttribType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::InstrAttribType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::InstrAttribType *)new FIX::InstrAttribType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstrAttribType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_InstrAttribType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrAttribType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "InstrAttribType.new", 
    "    InstrAttribType.new()\n"
    "    InstrAttribType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrAttribType(FIX::InstrAttribType *arg1) {
    delete arg1;
}

swig_class SwigClassProduct;

SWIGINTERN VALUE
_wrap_new_Product__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Product";
  FIX::Product *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Product *)new FIX::Product();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Product_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Product_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Product);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Product__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Product";
  FIX::Product *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Product", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Product", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Product *)new FIX::Product((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Product(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Product__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Product__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Product.new", 
    "    Product.new()\n"
    "    Product.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Product(FIX::Product *arg1) {
    delete arg1;
}

swig_class SwigClassAllocShares;

SWIGINTERN VALUE
_wrap_new_AllocShares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocShares";
  FIX::AllocShares *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocShares *)new FIX::AllocShares();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocShares_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocShares_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocShares);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocShares__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocShares";
  FIX::AllocShares *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::AllocShares", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::AllocShares", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::AllocShares *)new FIX::AllocShares((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocShares(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocShares__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocShares__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocShares.new", 
    "    AllocShares.new()\n"
    "    AllocShares.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocShares(FIX::AllocShares *arg1) {
    delete arg1;
}

swig_class SwigClassNoQuoteEntries;

SWIGINTERN VALUE
_wrap_new_NoQuoteEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteEntries";
  FIX::NoQuoteEntries *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoQuoteEntries *)new FIX::NoQuoteEntries();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoQuoteEntries_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoQuoteEntries_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoQuoteEntries);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoQuoteEntries__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteEntries";
  FIX::NoQuoteEntries *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoQuoteEntries", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoQuoteEntries", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoQuoteEntries *)new FIX::NoQuoteEntries((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoQuoteEntries(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoQuoteEntries__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoQuoteEntries__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoQuoteEntries.new", 
    "    NoQuoteEntries.new()\n"
    "    NoQuoteEntries.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoQuoteEntries(FIX::NoQuoteEntries *arg1) {
    delete arg1;
}

swig_class SwigClassDefaultCstmApplVerID;

SWIGINTERN VALUE
_wrap_new_DefaultCstmApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DefaultCstmApplVerID";
  FIX::DefaultCstmApplVerID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DefaultCstmApplVerID *)new FIX::DefaultCstmApplVerID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DefaultCstmApplVerID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DefaultCstmApplVerID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DefaultCstmApplVerID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DefaultCstmApplVerID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultCstmApplVerID";
  FIX::DefaultCstmApplVerID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DefaultCstmApplVerID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DefaultCstmApplVerID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DefaultCstmApplVerID *)new FIX::DefaultCstmApplVerID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefaultCstmApplVerID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DefaultCstmApplVerID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultCstmApplVerID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DefaultCstmApplVerID.new", 
    "    DefaultCstmApplVerID.new()\n"
    "    DefaultCstmApplVerID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultCstmApplVerID(FIX::DefaultCstmApplVerID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeListMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeListMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeListMethod";
  FIX::DerivativeListMethod *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeListMethod *)new FIX::DerivativeListMethod();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeListMethod_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeListMethod_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeListMethod);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeListMethod__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeListMethod";
  FIX::DerivativeListMethod *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativeListMethod", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativeListMethod", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativeListMethod *)new FIX::DerivativeListMethod((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeListMethod(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeListMethod__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeListMethod__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeListMethod.new", 
    "    DerivativeListMethod.new()\n"
    "    DerivativeListMethod.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeListMethod(FIX::DerivativeListMethod *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityXMLLen;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXMLLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLLen";
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityXMLLen *)new FIX::DerivativeSecurityXMLLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityXMLLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityXMLLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityXMLLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXMLLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLLen";
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::DerivativeSecurityXMLLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::DerivativeSecurityXMLLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::DerivativeSecurityXMLLen *)new FIX::DerivativeSecurityXMLLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityXMLLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityXMLLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityXMLLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityXMLLen.new", 
    "    DerivativeSecurityXMLLen.new()\n"
    "    DerivativeSecurityXMLLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityXMLLen(FIX::DerivativeSecurityXMLLen *arg1) {
    delete arg1;
}

swig_class SwigClassLegDatedDate;

SWIGINTERN VALUE
_wrap_new_LegDatedDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegDatedDate";
  FIX::LegDatedDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegDatedDate *)new FIX::LegDatedDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegDatedDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegDatedDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegDatedDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegDatedDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegDatedDate";
  FIX::LegDatedDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegDatedDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegDatedDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegDatedDate *)new FIX::LegDatedDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegDatedDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegDatedDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegDatedDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegDatedDate.new", 
    "    LegDatedDate.new()\n"
    "    LegDatedDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegDatedDate(FIX::LegDatedDate *arg1) {
    delete arg1;
}

swig_class SwigClassNested2PartyIDSource;

SWIGINTERN VALUE
_wrap_new_Nested2PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyIDSource";
  FIX::Nested2PartyIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested2PartyIDSource *)new FIX::Nested2PartyIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested2PartyIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested2PartyIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested2PartyIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested2PartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyIDSource";
  FIX::Nested2PartyIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Nested2PartyIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Nested2PartyIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Nested2PartyIDSource *)new FIX::Nested2PartyIDSource((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested2PartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested2PartyIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested2PartyIDSource.new", 
    "    Nested2PartyIDSource.new()\n"
    "    Nested2PartyIDSource.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartyIDSource(FIX::Nested2PartyIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingInstrRegistry;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrRegistry";
  FIX::UnderlyingInstrRegistry *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingInstrRegistry *)new FIX::UnderlyingInstrRegistry();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingInstrRegistry_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingInstrRegistry_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingInstrRegistry);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrRegistry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrRegistry";
  FIX::UnderlyingInstrRegistry *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingInstrRegistry", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingInstrRegistry", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingInstrRegistry *)new FIX::UnderlyingInstrRegistry((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingInstrRegistry(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingInstrRegistry__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrRegistry__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingInstrRegistry.new", 
    "    UnderlyingInstrRegistry.new()\n"
    "    UnderlyingInstrRegistry.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrRegistry(FIX::UnderlyingInstrRegistry *arg1) {
    delete arg1;
}

swig_class SwigClassIssueDate;

SWIGINTERN VALUE
_wrap_new_IssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IssueDate";
  FIX::IssueDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IssueDate *)new FIX::IssueDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IssueDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IssueDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IssueDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IssueDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IssueDate";
  FIX::IssueDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::IssueDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::IssueDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::IssueDate *)new FIX::IssueDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IssueDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IssueDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IssueDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IssueDate.new", 
    "    IssueDate.new()\n"
    "    IssueDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IssueDate(FIX::IssueDate *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityTradingStatus;

SWIGINTERN VALUE
_wrap_new_SecurityTradingStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingStatus";
  FIX::SecurityTradingStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityTradingStatus *)new FIX::SecurityTradingStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityTradingStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityTradingStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityTradingStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityTradingStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingStatus";
  FIX::SecurityTradingStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::SecurityTradingStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::SecurityTradingStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::SecurityTradingStatus *)new FIX::SecurityTradingStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityTradingStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityTradingStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityTradingStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityTradingStatus.new", 
    "    SecurityTradingStatus.new()\n"
    "    SecurityTradingStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityTradingStatus(FIX::SecurityTradingStatus *arg1) {
    delete arg1;
}

swig_class SwigClassLegOptAttribute;

SWIGINTERN VALUE
_wrap_new_LegOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegOptAttribute";
  FIX::LegOptAttribute *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegOptAttribute *)new FIX::LegOptAttribute();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegOptAttribute_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegOptAttribute_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegOptAttribute);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegOptAttribute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOptAttribute";
  FIX::LegOptAttribute *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LegOptAttribute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LegOptAttribute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LegOptAttribute *)new FIX::LegOptAttribute((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegOptAttribute(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegOptAttribute__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOptAttribute__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegOptAttribute.new", 
    "    LegOptAttribute.new()\n"
    "    LegOptAttribute.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOptAttribute(FIX::LegOptAttribute *arg1) {
    delete arg1;
}

swig_class SwigClassMaxFloor;

SWIGINTERN VALUE
_wrap_new_MaxFloor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaxFloor";
  FIX::MaxFloor *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaxFloor *)new FIX::MaxFloor();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaxFloor_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaxFloor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaxFloor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaxFloor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxFloor";
  FIX::MaxFloor *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::MaxFloor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::MaxFloor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::MaxFloor *)new FIX::MaxFloor((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaxFloor(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaxFloor__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxFloor__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaxFloor.new", 
    "    MaxFloor.new()\n"
    "    MaxFloor.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxFloor(FIX::MaxFloor *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_DerivativeLocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeLocaleOfIssue";
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeLocaleOfIssue *)new FIX::DerivativeLocaleOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeLocaleOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeLocaleOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeLocaleOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeLocaleOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeLocaleOfIssue";
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeLocaleOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeLocaleOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeLocaleOfIssue *)new FIX::DerivativeLocaleOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeLocaleOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeLocaleOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeLocaleOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeLocaleOfIssue.new", 
    "    DerivativeLocaleOfIssue.new()\n"
    "    DerivativeLocaleOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeLocaleOfIssue(FIX::DerivativeLocaleOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassOptPayAmount;

SWIGINTERN VALUE
_wrap_new_OptPayAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OptPayAmount";
  FIX::OptPayAmount *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OptPayAmount *)new FIX::OptPayAmount();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OptPayAmount_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OptPayAmount_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OptPayAmount);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OptPayAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayAmount";
  FIX::OptPayAmount *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::OptPayAmount", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::OptPayAmount", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::OptPayAmount *)new FIX::OptPayAmount((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OptPayAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OptPayAmount__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptPayAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OptPayAmount.new", 
    "    OptPayAmount.new()\n"
    "    OptPayAmount.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OptPayAmount(FIX::OptPayAmount *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingStipType;

SWIGINTERN VALUE
_wrap_new_UnderlyingStipType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipType";
  FIX::UnderlyingStipType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingStipType *)new FIX::UnderlyingStipType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingStipType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingStipType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingStipType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingStipType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipType";
  FIX::UnderlyingStipType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingStipType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingStipType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingStipType *)new FIX::UnderlyingStipType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingStipType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingStipType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStipType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingStipType.new", 
    "    UnderlyingStipType.new()\n"
    "    UnderlyingStipType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStipType(FIX::UnderlyingStipType *arg1) {
    delete arg1;
}

swig_class SwigClassRule80A;

SWIGINTERN VALUE
_wrap_new_Rule80A__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Rule80A";
  FIX::Rule80A *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Rule80A *)new FIX::Rule80A();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Rule80A_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Rule80A_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Rule80A);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Rule80A__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Rule80A";
  FIX::Rule80A *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::Rule80A", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::Rule80A", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::Rule80A *)new FIX::Rule80A((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Rule80A(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Rule80A__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Rule80A__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Rule80A.new", 
    "    Rule80A.new()\n"
    "    Rule80A.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Rule80A(FIX::Rule80A *arg1) {
    delete arg1;
}

swig_class SwigClassTotNoStrikes;

SWIGINTERN VALUE
_wrap_new_TotNoStrikes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TotNoStrikes";
  FIX::TotNoStrikes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TotNoStrikes *)new FIX::TotNoStrikes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TotNoStrikes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TotNoStrikes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TotNoStrikes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TotNoStrikes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoStrikes";
  FIX::TotNoStrikes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TotNoStrikes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TotNoStrikes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TotNoStrikes *)new FIX::TotNoStrikes((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TotNoStrikes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoStrikes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoStrikes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TotNoStrikes.new", 
    "    TotNoStrikes.new()\n"
    "    TotNoStrikes.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoStrikes(FIX::TotNoStrikes *arg1) {
    delete arg1;
}

swig_class SwigClassCorporateAction;

SWIGINTERN VALUE
_wrap_new_CorporateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CorporateAction";
  FIX::CorporateAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CorporateAction *)new FIX::CorporateAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CorporateAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CorporateAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CorporateAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CorporateAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CorporateAction";
  FIX::CorporateAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLECHARVALUE const &","FIX::CorporateAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLECHARVALUE const &","FIX::CorporateAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  result = (FIX::CorporateAction *)new FIX::CorporateAction((FIX::MULTIPLECHARVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CorporateAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CorporateAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CorporateAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CorporateAction.new", 
    "    CorporateAction.new()\n"
    "    CorporateAction.new(FIX::MULTIPLECHARVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CorporateAction(FIX::CorporateAction *arg1) {
    delete arg1;
}

swig_class SwigClassTerminationType;

SWIGINTERN VALUE
_wrap_new_TerminationType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TerminationType";
  FIX::TerminationType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TerminationType *)new FIX::TerminationType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TerminationType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TerminationType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TerminationType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TerminationType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TerminationType";
  FIX::TerminationType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TerminationType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TerminationType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TerminationType *)new FIX::TerminationType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TerminationType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TerminationType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TerminationType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TerminationType.new", 
    "    TerminationType.new()\n"
    "    TerminationType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TerminationType(FIX::TerminationType *arg1) {
    delete arg1;
}

swig_class SwigClassLegCouponRate;

SWIGINTERN VALUE
_wrap_new_LegCouponRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCouponRate";
  FIX::LegCouponRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCouponRate *)new FIX::LegCouponRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCouponRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCouponRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCouponRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCouponRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCouponRate";
  FIX::LegCouponRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::LegCouponRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::LegCouponRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::LegCouponRate *)new FIX::LegCouponRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCouponRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCouponRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCouponRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCouponRate.new", 
    "    LegCouponRate.new()\n"
    "    LegCouponRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCouponRate(FIX::LegCouponRate *arg1) {
    delete arg1;
}

swig_class SwigClassPosMaintAction;

SWIGINTERN VALUE
_wrap_new_PosMaintAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosMaintAction";
  FIX::PosMaintAction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosMaintAction *)new FIX::PosMaintAction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosMaintAction_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosMaintAction_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosMaintAction);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosMaintAction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintAction";
  FIX::PosMaintAction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosMaintAction", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosMaintAction", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosMaintAction *)new FIX::PosMaintAction((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosMaintAction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosMaintAction__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintAction__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosMaintAction.new", 
    "    PosMaintAction.new()\n"
    "    PosMaintAction.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintAction(FIX::PosMaintAction *arg1) {
    delete arg1;
}

swig_class SwigClassNoSecurityTypes;

SWIGINTERN VALUE
_wrap_new_NoSecurityTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityTypes";
  FIX::NoSecurityTypes *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoSecurityTypes *)new FIX::NoSecurityTypes();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoSecurityTypes_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoSecurityTypes_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoSecurityTypes);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoSecurityTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityTypes";
  FIX::NoSecurityTypes *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoSecurityTypes", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoSecurityTypes", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoSecurityTypes *)new FIX::NoSecurityTypes((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoSecurityTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoSecurityTypes__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSecurityTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoSecurityTypes.new", 
    "    NoSecurityTypes.new()\n"
    "    NoSecurityTypes.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSecurityTypes(FIX::NoSecurityTypes *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventPriceTimeType;

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceTimeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceTimeType";
  FIX::ComplexEventPriceTimeType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventPriceTimeType *)new FIX::ComplexEventPriceTimeType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventPriceTimeType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventPriceTimeType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventPriceTimeType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceTimeType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceTimeType";
  FIX::ComplexEventPriceTimeType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ComplexEventPriceTimeType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ComplexEventPriceTimeType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ComplexEventPriceTimeType *)new FIX::ComplexEventPriceTimeType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventPriceTimeType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventPriceTimeType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPriceTimeType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventPriceTimeType.new", 
    "    ComplexEventPriceTimeType.new()\n"
    "    ComplexEventPriceTimeType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPriceTimeType(FIX::ComplexEventPriceTimeType *arg1) {
    delete arg1;
}

swig_class SwigClassLastSwapPoints;

SWIGINTERN VALUE
_wrap_new_LastSwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LastSwapPoints";
  FIX::LastSwapPoints *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LastSwapPoints *)new FIX::LastSwapPoints();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LastSwapPoints_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LastSwapPoints_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LastSwapPoints);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LastSwapPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastSwapPoints";
  FIX::LastSwapPoints *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICEOFFSET const &","FIX::LastSwapPoints", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICEOFFSET const &","FIX::LastSwapPoints", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  result = (FIX::LastSwapPoints *)new FIX::LastSwapPoints((FIX::PRICEOFFSET const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LastSwapPoints(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LastSwapPoints__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastSwapPoints__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LastSwapPoints.new", 
    "    LastSwapPoints.new()\n"
    "    LastSwapPoints.new(FIX::PRICEOFFSET const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LastSwapPoints(FIX::LastSwapPoints *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingFXRateCalc;

SWIGINTERN VALUE
_wrap_new_UnderlyingFXRateCalc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRateCalc";
  FIX::UnderlyingFXRateCalc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingFXRateCalc *)new FIX::UnderlyingFXRateCalc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingFXRateCalc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingFXRateCalc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingFXRateCalc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingFXRateCalc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRateCalc";
  FIX::UnderlyingFXRateCalc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::UnderlyingFXRateCalc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::UnderlyingFXRateCalc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::UnderlyingFXRateCalc *)new FIX::UnderlyingFXRateCalc((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingFXRateCalc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingFXRateCalc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFXRateCalc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingFXRateCalc.new", 
    "    UnderlyingFXRateCalc.new()\n"
    "    UnderlyingFXRateCalc.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFXRateCalc(FIX::UnderlyingFXRateCalc *arg1) {
    delete arg1;
}

swig_class SwigClassListStatusText;

SWIGINTERN VALUE
_wrap_new_ListStatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListStatusText";
  FIX::ListStatusText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListStatusText *)new FIX::ListStatusText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListStatusText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListStatusText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListStatusText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListStatusText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListStatusText";
  FIX::ListStatusText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ListStatusText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ListStatusText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ListStatusText *)new FIX::ListStatusText((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListStatusText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListStatusText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListStatusText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListStatusText.new", 
    "    ListStatusText.new()\n"
    "    ListStatusText.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListStatusText(FIX::ListStatusText *arg1) {
    delete arg1;
}

swig_class SwigClassOddLot;

SWIGINTERN VALUE
_wrap_new_OddLot__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OddLot";
  FIX::OddLot *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OddLot *)new FIX::OddLot();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OddLot_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OddLot_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OddLot);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OddLot__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OddLot";
  FIX::OddLot *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::OddLot", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::OddLot", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::OddLot *)new FIX::OddLot((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OddLot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OddLot__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OddLot__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OddLot.new", 
    "    OddLot.new()\n"
    "    OddLot.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OddLot(FIX::OddLot *arg1) {
    delete arg1;
}

swig_class SwigClassBookingUnit;

SWIGINTERN VALUE
_wrap_new_BookingUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BookingUnit";
  FIX::BookingUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BookingUnit *)new FIX::BookingUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BookingUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BookingUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BookingUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BookingUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingUnit";
  FIX::BookingUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::BookingUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::BookingUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::BookingUnit *)new FIX::BookingUnit((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BookingUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BookingUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BookingUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BookingUnit.new", 
    "    BookingUnit.new()\n"
    "    BookingUnit.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BookingUnit(FIX::BookingUnit *arg1) {
    delete arg1;
}

swig_class SwigClassLegAllocAcctIDSource;

SWIGINTERN VALUE
_wrap_new_LegAllocAcctIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAcctIDSource";
  FIX::LegAllocAcctIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegAllocAcctIDSource *)new FIX::LegAllocAcctIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegAllocAcctIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegAllocAcctIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegAllocAcctIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegAllocAcctIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAcctIDSource";
  FIX::LegAllocAcctIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegAllocAcctIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegAllocAcctIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegAllocAcctIDSource *)new FIX::LegAllocAcctIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegAllocAcctIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegAllocAcctIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocAcctIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegAllocAcctIDSource.new", 
    "    LegAllocAcctIDSource.new()\n"
    "    LegAllocAcctIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocAcctIDSource(FIX::LegAllocAcctIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassOnBehalfOfSendingTime;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfSendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OnBehalfOfSendingTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::OnBehalfOfSendingTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_OnBehalfOfSendingTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OnBehalfOfSendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OnBehalfOfSendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OnBehalfOfSendingTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OnBehalfOfSendingTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OnBehalfOfSendingTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OnBehalfOfSendingTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::OnBehalfOfSendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::OnBehalfOfSendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::OnBehalfOfSendingTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OnBehalfOfSendingTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OnBehalfOfSendingTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfSendingTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_OnBehalfOfSendingTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OnBehalfOfSendingTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "OnBehalfOfSendingTime.new", 
    "    OnBehalfOfSendingTime.new()\n"
    "    OnBehalfOfSendingTime.new(bool showMilliseconds)\n"
    "    OnBehalfOfSendingTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    OnBehalfOfSendingTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfSendingTime(FIX::OnBehalfOfSendingTime *arg1) {
    delete arg1;
}

swig_class SwigClassAllocStatus;

SWIGINTERN VALUE
_wrap_new_AllocStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AllocStatus";
  FIX::AllocStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AllocStatus *)new FIX::AllocStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AllocStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AllocStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AllocStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AllocStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocStatus";
  FIX::AllocStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AllocStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AllocStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AllocStatus *)new FIX::AllocStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AllocStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AllocStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AllocStatus.new", 
    "    AllocStatus.new()\n"
    "    AllocStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocStatus(FIX::AllocStatus *arg1) {
    delete arg1;
}

swig_class SwigClassReferencePage;

SWIGINTERN VALUE
_wrap_new_ReferencePage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ReferencePage";
  FIX::ReferencePage *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ReferencePage *)new FIX::ReferencePage();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ReferencePage_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ReferencePage_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ReferencePage);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ReferencePage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReferencePage";
  FIX::ReferencePage *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ReferencePage", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ReferencePage", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ReferencePage *)new FIX::ReferencePage((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ReferencePage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ReferencePage__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReferencePage__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ReferencePage.new", 
    "    ReferencePage.new()\n"
    "    ReferencePage.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ReferencePage(FIX::ReferencePage *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeExerciseStyle;

SWIGINTERN VALUE
_wrap_new_DerivativeExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeExerciseStyle";
  FIX::DerivativeExerciseStyle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeExerciseStyle *)new FIX::DerivativeExerciseStyle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeExerciseStyle_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeExerciseStyle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeExerciseStyle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeExerciseStyle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeExerciseStyle";
  FIX::DerivativeExerciseStyle *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DerivativeExerciseStyle", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DerivativeExerciseStyle", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DerivativeExerciseStyle *)new FIX::DerivativeExerciseStyle((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeExerciseStyle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeExerciseStyle__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeExerciseStyle__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeExerciseStyle.new", 
    "    DerivativeExerciseStyle.new()\n"
    "    DerivativeExerciseStyle.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeExerciseStyle(FIX::DerivativeExerciseStyle *arg1) {
    delete arg1;
}

swig_class SwigClassApplBegSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplBegSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplBegSeqNum";
  FIX::ApplBegSeqNum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplBegSeqNum *)new FIX::ApplBegSeqNum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplBegSeqNum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplBegSeqNum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplBegSeqNum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplBegSeqNum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplBegSeqNum";
  FIX::ApplBegSeqNum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SEQNUM,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SEQNUM const &","FIX::ApplBegSeqNum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SEQNUM const &","FIX::ApplBegSeqNum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  result = (FIX::ApplBegSeqNum *)new FIX::ApplBegSeqNum((FIX::SEQNUM const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplBegSeqNum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplBegSeqNum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplBegSeqNum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplBegSeqNum.new", 
    "    ApplBegSeqNum.new()\n"
    "    ApplBegSeqNum.new(FIX::SEQNUM const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplBegSeqNum(FIX::ApplBegSeqNum *arg1) {
    delete arg1;
}

swig_class SwigClassCollRptID;

SWIGINTERN VALUE
_wrap_new_CollRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CollRptID";
  FIX::CollRptID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CollRptID *)new FIX::CollRptID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CollRptID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CollRptID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CollRptID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CollRptID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollRptID";
  FIX::CollRptID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CollRptID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CollRptID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CollRptID *)new FIX::CollRptID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CollRptID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CollRptID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollRptID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CollRptID.new", 
    "    CollRptID.new()\n"
    "    CollRptID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CollRptID(FIX::CollRptID *arg1) {
    delete arg1;
}

swig_class SwigClassIncTaxInd;

SWIGINTERN VALUE
_wrap_new_IncTaxInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IncTaxInd";
  FIX::IncTaxInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IncTaxInd *)new FIX::IncTaxInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IncTaxInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IncTaxInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IncTaxInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IncTaxInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncTaxInd";
  FIX::IncTaxInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::IncTaxInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::IncTaxInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::IncTaxInd *)new FIX::IncTaxInd((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IncTaxInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IncTaxInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IncTaxInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IncTaxInd.new", 
    "    IncTaxInd.new()\n"
    "    IncTaxInd.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IncTaxInd(FIX::IncTaxInd *arg1) {
    delete arg1;
}

swig_class SwigClassNoBidDescriptors;

SWIGINTERN VALUE
_wrap_new_NoBidDescriptors__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoBidDescriptors";
  FIX::NoBidDescriptors *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoBidDescriptors *)new FIX::NoBidDescriptors();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoBidDescriptors_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoBidDescriptors_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoBidDescriptors);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoBidDescriptors__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoBidDescriptors";
  FIX::NoBidDescriptors *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoBidDescriptors", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoBidDescriptors", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoBidDescriptors *)new FIX::NoBidDescriptors((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoBidDescriptors(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoBidDescriptors__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoBidDescriptors__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoBidDescriptors.new", 
    "    NoBidDescriptors.new()\n"
    "    NoBidDescriptors.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoBidDescriptors(FIX::NoBidDescriptors *arg1) {
    delete arg1;
}

swig_class SwigClassLegCouponPaymentDate;

SWIGINTERN VALUE
_wrap_new_LegCouponPaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegCouponPaymentDate";
  FIX::LegCouponPaymentDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegCouponPaymentDate *)new FIX::LegCouponPaymentDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegCouponPaymentDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegCouponPaymentDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegCouponPaymentDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegCouponPaymentDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCouponPaymentDate";
  FIX::LegCouponPaymentDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegCouponPaymentDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegCouponPaymentDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegCouponPaymentDate *)new FIX::LegCouponPaymentDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegCouponPaymentDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegCouponPaymentDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCouponPaymentDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegCouponPaymentDate.new", 
    "    LegCouponPaymentDate.new()\n"
    "    LegCouponPaymentDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCouponPaymentDate(FIX::LegCouponPaymentDate *arg1) {
    delete arg1;
}

swig_class SwigClassNoUnderlyingLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingLegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingLegSecurityAltID";
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoUnderlyingLegSecurityAltID *)new FIX::NoUnderlyingLegSecurityAltID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoUnderlyingLegSecurityAltID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoUnderlyingLegSecurityAltID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoUnderlyingLegSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingLegSecurityAltID";
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoUnderlyingLegSecurityAltID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoUnderlyingLegSecurityAltID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoUnderlyingLegSecurityAltID *)new FIX::NoUnderlyingLegSecurityAltID((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoUnderlyingLegSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoUnderlyingLegSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingLegSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoUnderlyingLegSecurityAltID.new", 
    "    NoUnderlyingLegSecurityAltID.new()\n"
    "    NoUnderlyingLegSecurityAltID.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingLegSecurityAltID(FIX::NoUnderlyingLegSecurityAltID *arg1) {
    delete arg1;
}

swig_class SwigClassReversalIndicator;

SWIGINTERN VALUE
_wrap_new_ReversalIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ReversalIndicator";
  FIX::ReversalIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ReversalIndicator *)new FIX::ReversalIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ReversalIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ReversalIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ReversalIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ReversalIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReversalIndicator";
  FIX::ReversalIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::ReversalIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::ReversalIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::ReversalIndicator *)new FIX::ReversalIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ReversalIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ReversalIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReversalIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ReversalIndicator.new", 
    "    ReversalIndicator.new()\n"
    "    ReversalIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ReversalIndicator(FIX::ReversalIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassCheckSum;

SWIGINTERN VALUE
_wrap_new_CheckSum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CheckSum";
  FIX::CheckSum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CheckSum *)new FIX::CheckSum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CheckSum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CheckSum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CheckSum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CheckSum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSum";
  FIX::CheckSum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CheckSum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CheckSum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CheckSum *)new FIX::CheckSum((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CheckSum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CheckSum__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CheckSum__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CheckSum.new", 
    "    CheckSum.new()\n"
    "    CheckSum.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CheckSum(FIX::CheckSum *arg1) {
    delete arg1;
}

swig_class SwigClassTargetSubID;

SWIGINTERN VALUE
_wrap_new_TargetSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetSubID";
  FIX::TargetSubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetSubID *)new FIX::TargetSubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetSubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetSubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetSubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetSubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetSubID";
  FIX::TargetSubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TargetSubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TargetSubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TargetSubID *)new FIX::TargetSubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetSubID.new", 
    "    TargetSubID.new()\n"
    "    TargetSubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetSubID(FIX::TargetSubID *arg1) {
    delete arg1;
}

swig_class SwigClassPosReqStatus;

SWIGINTERN VALUE
_wrap_new_PosReqStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PosReqStatus";
  FIX::PosReqStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PosReqStatus *)new FIX::PosReqStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PosReqStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PosReqStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PosReqStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PosReqStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqStatus";
  FIX::PosReqStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PosReqStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PosReqStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PosReqStatus *)new FIX::PosReqStatus((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PosReqStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PosReqStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PosReqStatus.new", 
    "    PosReqStatus.new()\n"
    "    PosReqStatus.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqStatus(FIX::PosReqStatus *arg1) {
    delete arg1;
}

swig_class SwigClassPriorityIndicator;

SWIGINTERN VALUE
_wrap_new_PriorityIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::PriorityIndicator";
  FIX::PriorityIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::PriorityIndicator *)new FIX::PriorityIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PriorityIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PriorityIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__PriorityIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PriorityIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorityIndicator";
  FIX::PriorityIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::PriorityIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::PriorityIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::PriorityIndicator *)new FIX::PriorityIndicator((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PriorityIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PriorityIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriorityIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PriorityIndicator.new", 
    "    PriorityIndicator.new()\n"
    "    PriorityIndicator.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_PriorityIndicator(FIX::PriorityIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegCFICode;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegCFICode";
  FIX::UnderlyingLegCFICode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegCFICode *)new FIX::UnderlyingLegCFICode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegCFICode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegCFICode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegCFICode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegCFICode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegCFICode";
  FIX::UnderlyingLegCFICode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegCFICode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegCFICode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegCFICode *)new FIX::UnderlyingLegCFICode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegCFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegCFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegCFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegCFICode.new", 
    "    UnderlyingLegCFICode.new()\n"
    "    UnderlyingLegCFICode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegCFICode(FIX::UnderlyingLegCFICode *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeTimeUnit;

SWIGINTERN VALUE
_wrap_new_DerivativeTimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeTimeUnit";
  FIX::DerivativeTimeUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeTimeUnit *)new FIX::DerivativeTimeUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeTimeUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeTimeUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeTimeUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeTimeUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeTimeUnit";
  FIX::DerivativeTimeUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeTimeUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeTimeUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeTimeUnit *)new FIX::DerivativeTimeUnit((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeTimeUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeTimeUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeTimeUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeTimeUnit.new", 
    "    DerivativeTimeUnit.new()\n"
    "    DerivativeTimeUnit.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeTimeUnit(FIX::DerivativeTimeUnit *arg1) {
    delete arg1;
}

swig_class SwigClassNoNested3PartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNested3PartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartyIDs";
  FIX::NoNested3PartyIDs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoNested3PartyIDs *)new FIX::NoNested3PartyIDs();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoNested3PartyIDs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoNested3PartyIDs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoNested3PartyIDs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoNested3PartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartyIDs";
  FIX::NoNested3PartyIDs *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoNested3PartyIDs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoNested3PartyIDs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoNested3PartyIDs *)new FIX::NoNested3PartyIDs((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoNested3PartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoNested3PartyIDs__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested3PartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoNested3PartyIDs.new", 
    "    NoNested3PartyIDs.new()\n"
    "    NoNested3PartyIDs.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested3PartyIDs(FIX::NoNested3PartyIDs *arg1) {
    delete arg1;
}

swig_class SwigClassLiquidityPctHigh;

SWIGINTERN VALUE
_wrap_new_LiquidityPctHigh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctHigh";
  FIX::LiquidityPctHigh *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LiquidityPctHigh *)new FIX::LiquidityPctHigh();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LiquidityPctHigh_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LiquidityPctHigh_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LiquidityPctHigh);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LiquidityPctHigh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctHigh";
  FIX::LiquidityPctHigh *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::LiquidityPctHigh", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::LiquidityPctHigh", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::LiquidityPctHigh *)new FIX::LiquidityPctHigh((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LiquidityPctHigh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LiquidityPctHigh__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityPctHigh__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LiquidityPctHigh.new", 
    "    LiquidityPctHigh.new()\n"
    "    LiquidityPctHigh.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityPctHigh(FIX::LiquidityPctHigh *arg1) {
    delete arg1;
}

swig_class SwigClassMoneyLaunderingStatus;

SWIGINTERN VALUE
_wrap_new_MoneyLaunderingStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MoneyLaunderingStatus";
  FIX::MoneyLaunderingStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MoneyLaunderingStatus *)new FIX::MoneyLaunderingStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MoneyLaunderingStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MoneyLaunderingStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MoneyLaunderingStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MoneyLaunderingStatus";
  FIX::MoneyLaunderingStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MoneyLaunderingStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MoneyLaunderingStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MoneyLaunderingStatus *)new FIX::MoneyLaunderingStatus((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MoneyLaunderingStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MoneyLaunderingStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoneyLaunderingStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MoneyLaunderingStatus.new", 
    "    MoneyLaunderingStatus.new()\n"
    "    MoneyLaunderingStatus.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MoneyLaunderingStatus(FIX::MoneyLaunderingStatus *arg1) {
    delete arg1;
}

swig_class SwigClassNested4PartySubID;

SWIGINTERN VALUE
_wrap_new_Nested4PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubID";
  FIX::Nested4PartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested4PartySubID *)new FIX::Nested4PartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested4PartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested4PartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested4PartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested4PartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubID";
  FIX::Nested4PartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Nested4PartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Nested4PartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Nested4PartySubID *)new FIX::Nested4PartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested4PartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested4PartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested4PartySubID.new", 
    "    Nested4PartySubID.new()\n"
    "    Nested4PartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartySubID(FIX::Nested4PartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityExchange;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityExchange";
  FIX::DerivativeSecurityExchange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityExchange *)new FIX::DerivativeSecurityExchange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityExchange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityExchange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityExchange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityExchange";
  FIX::DerivativeSecurityExchange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::EXCHANGE const &","FIX::DerivativeSecurityExchange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::EXCHANGE const &","FIX::DerivativeSecurityExchange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::DerivativeSecurityExchange *)new FIX::DerivativeSecurityExchange((FIX::EXCHANGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityExchange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityExchange.new", 
    "    DerivativeSecurityExchange.new()\n"
    "    DerivativeSecurityExchange.new(FIX::EXCHANGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityExchange(FIX::DerivativeSecurityExchange *arg1) {
    delete arg1;
}

swig_class SwigClassLotType;

SWIGINTERN VALUE
_wrap_new_LotType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LotType";
  FIX::LotType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LotType *)new FIX::LotType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LotType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LotType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LotType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LotType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LotType";
  FIX::LotType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::LotType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::LotType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::LotType *)new FIX::LotType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LotType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LotType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LotType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LotType.new", 
    "    LotType.new()\n"
    "    LotType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LotType(FIX::LotType *arg1) {
    delete arg1;
}

swig_class SwigClassContIntRptID;

SWIGINTERN VALUE
_wrap_new_ContIntRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ContIntRptID";
  FIX::ContIntRptID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ContIntRptID *)new FIX::ContIntRptID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ContIntRptID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ContIntRptID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ContIntRptID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ContIntRptID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContIntRptID";
  FIX::ContIntRptID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ContIntRptID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ContIntRptID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ContIntRptID *)new FIX::ContIntRptID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContIntRptID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContIntRptID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContIntRptID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ContIntRptID.new", 
    "    ContIntRptID.new()\n"
    "    ContIntRptID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ContIntRptID(FIX::ContIntRptID *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteCondition;

SWIGINTERN VALUE
_wrap_new_QuoteCondition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteCondition";
  FIX::QuoteCondition *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteCondition *)new FIX::QuoteCondition();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteCondition_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteCondition_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteCondition);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteCondition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteCondition";
  FIX::QuoteCondition *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MULTIPLESTRINGVALUE const &","FIX::QuoteCondition", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MULTIPLESTRINGVALUE const &","FIX::QuoteCondition", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  result = (FIX::QuoteCondition *)new FIX::QuoteCondition((FIX::MULTIPLESTRINGVALUE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteCondition(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteCondition__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteCondition__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteCondition.new", 
    "    QuoteCondition.new()\n"
    "    QuoteCondition.new(FIX::MULTIPLESTRINGVALUE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteCondition(FIX::QuoteCondition *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventStartTime;

SWIGINTERN VALUE
_wrap_new_ComplexEventStartTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartTime";
  FIX::ComplexEventStartTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventStartTime *)new FIX::ComplexEventStartTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventStartTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventStartTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventStartTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventStartTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartTime";
  FIX::ComplexEventStartTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMEONLY const &","FIX::ComplexEventStartTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMEONLY const &","FIX::ComplexEventStartTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  result = (FIX::ComplexEventStartTime *)new FIX::ComplexEventStartTime((FIX::UTCTIMEONLY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventStartTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventStartTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventStartTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ComplexEventStartTime.new", 
    "    ComplexEventStartTime.new()\n"
    "    ComplexEventStartTime.new(FIX::UTCTIMEONLY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventStartTime(FIX::ComplexEventStartTime *arg1) {
    delete arg1;
}

swig_class SwigClassNoComplexEvents;

SWIGINTERN VALUE
_wrap_new_NoComplexEvents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEvents";
  FIX::NoComplexEvents *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoComplexEvents *)new FIX::NoComplexEvents();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoComplexEvents_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoComplexEvents_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoComplexEvents);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoComplexEvents__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEvents";
  FIX::NoComplexEvents *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoComplexEvents", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoComplexEvents", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoComplexEvents *)new FIX::NoComplexEvents((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoComplexEvents(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoComplexEvents__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoComplexEvents__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoComplexEvents.new", 
    "    NoComplexEvents.new()\n"
    "    NoComplexEvents.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoComplexEvents(FIX::NoComplexEvents *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeContractMultiplier;

SWIGINTERN VALUE
_wrap_new_DerivativeContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplier";
  FIX::DerivativeContractMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeContractMultiplier *)new FIX::DerivativeContractMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeContractMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeContractMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeContractMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeContractMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplier";
  FIX::DerivativeContractMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::DerivativeContractMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::DerivativeContractMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::DerivativeContractMultiplier *)new FIX::DerivativeContractMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeContractMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeContractMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeContractMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeContractMultiplier.new", 
    "    DerivativeContractMultiplier.new()\n"
    "    DerivativeContractMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeContractMultiplier(FIX::DerivativeContractMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeSecurityStatus;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityStatus";
  FIX::DerivativeSecurityStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeSecurityStatus *)new FIX::DerivativeSecurityStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeSecurityStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeSecurityStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeSecurityStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityStatus";
  FIX::DerivativeSecurityStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeSecurityStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeSecurityStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeSecurityStatus *)new FIX::DerivativeSecurityStatus((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeSecurityStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeSecurityStatus.new", 
    "    DerivativeSecurityStatus.new()\n"
    "    DerivativeSecurityStatus.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityStatus(FIX::DerivativeSecurityStatus *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeProductComplex;

SWIGINTERN VALUE
_wrap_new_DerivativeProductComplex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProductComplex";
  FIX::DerivativeProductComplex *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeProductComplex *)new FIX::DerivativeProductComplex();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeProductComplex_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeProductComplex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeProductComplex);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeProductComplex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProductComplex";
  FIX::DerivativeProductComplex *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeProductComplex", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeProductComplex", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeProductComplex *)new FIX::DerivativeProductComplex((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeProductComplex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeProductComplex__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeProductComplex__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeProductComplex.new", 
    "    DerivativeProductComplex.new()\n"
    "    DerivativeProductComplex.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeProductComplex(FIX::DerivativeProductComplex *arg1) {
    delete arg1;
}

swig_class SwigClassTriggerSymbol;

SWIGINTERN VALUE
_wrap_new_TriggerSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TriggerSymbol";
  FIX::TriggerSymbol *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TriggerSymbol *)new FIX::TriggerSymbol();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriggerSymbol_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriggerSymbol_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TriggerSymbol);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriggerSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSymbol";
  FIX::TriggerSymbol *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TriggerSymbol", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TriggerSymbol", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TriggerSymbol *)new FIX::TriggerSymbol((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TriggerSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TriggerSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TriggerSymbol.new", 
    "    TriggerSymbol.new()\n"
    "    TriggerSymbol.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSymbol(FIX::TriggerSymbol *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_UnderlyingLocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLocaleOfIssue";
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLocaleOfIssue *)new FIX::UnderlyingLocaleOfIssue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLocaleOfIssue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLocaleOfIssue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLocaleOfIssue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLocaleOfIssue";
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLocaleOfIssue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLocaleOfIssue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLocaleOfIssue *)new FIX::UnderlyingLocaleOfIssue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLocaleOfIssue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLocaleOfIssue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLocaleOfIssue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLocaleOfIssue.new", 
    "    UnderlyingLocaleOfIssue.new()\n"
    "    UnderlyingLocaleOfIssue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLocaleOfIssue(FIX::UnderlyingLocaleOfIssue *arg1) {
    delete arg1;
}

swig_class SwigClassSendingTime;

SWIGINTERN VALUE
_wrap_new_SendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  FIX::SendingTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SendingTime *)new FIX::SendingTime();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SendingTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  FIX::SendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::SendingTime", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::SendingTime *)new FIX::SendingTime(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SendingTime__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  FIX::SendingTime *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::SendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::SendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::SendingTime *)new FIX::SendingTime((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SendingTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SendingTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SendingTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SendingTime__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  FIX::SendingTime *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::SendingTime", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::SendingTime", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::SendingTime", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::SendingTime *)new FIX::SendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SendingTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SendingTime__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SendingTime__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SendingTime__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SendingTime__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SendingTime.new", 
    "    SendingTime.new()\n"
    "    SendingTime.new(bool showMilliseconds)\n"
    "    SendingTime.new(FIX::UTCTIMESTAMP const &value)\n"
    "    SendingTime.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SendingTime(FIX::SendingTime *arg1) {
    delete arg1;
}

swig_class SwigClassComplexEventStartDate;

SWIGINTERN VALUE
_wrap_new_ComplexEventStartDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  FIX::ComplexEventStartDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ComplexEventStartDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  FIX::ComplexEventStartDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ComplexEventStartDate", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ComplexEventStartDate__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  FIX::ComplexEventStartDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventStartDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventStartDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate((FIX::UTCTIMESTAMP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ComplexEventStartDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ComplexEventStartDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ComplexEventStartDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ComplexEventStartDate__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  FIX::ComplexEventStartDate *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventStartDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UTCTIMESTAMP const &","FIX::ComplexEventStartDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ComplexEventStartDate", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate((FIX::UTCTIMESTAMP const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ComplexEventStartDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ComplexEventStartDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventStartDate__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ComplexEventStartDate__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ComplexEventStartDate__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ComplexEventStartDate.new", 
    "    ComplexEventStartDate.new()\n"
    "    ComplexEventStartDate.new(bool showMilliseconds)\n"
    "    ComplexEventStartDate.new(FIX::UTCTIMESTAMP const &value)\n"
    "    ComplexEventStartDate.new(FIX::UTCTIMESTAMP const &value, bool showMilliseconds)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventStartDate(FIX::ComplexEventStartDate *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingRestructuringType;

SWIGINTERN VALUE
_wrap_new_UnderlyingRestructuringType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRestructuringType";
  FIX::UnderlyingRestructuringType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingRestructuringType *)new FIX::UnderlyingRestructuringType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingRestructuringType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingRestructuringType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingRestructuringType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingRestructuringType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRestructuringType";
  FIX::UnderlyingRestructuringType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingRestructuringType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingRestructuringType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingRestructuringType *)new FIX::UnderlyingRestructuringType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingRestructuringType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingRestructuringType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRestructuringType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingRestructuringType.new", 
    "    UnderlyingRestructuringType.new()\n"
    "    UnderlyingRestructuringType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRestructuringType(FIX::UnderlyingRestructuringType *arg1) {
    delete arg1;
}

swig_class SwigClassLegUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_LegUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasureQty";
  FIX::LegUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegUnitOfMeasureQty *)new FIX::LegUnitOfMeasureQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegUnitOfMeasureQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegUnitOfMeasureQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegUnitOfMeasureQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegUnitOfMeasureQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasureQty";
  FIX::LegUnitOfMeasureQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegUnitOfMeasureQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegUnitOfMeasureQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegUnitOfMeasureQty *)new FIX::LegUnitOfMeasureQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegUnitOfMeasureQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegUnitOfMeasureQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegUnitOfMeasureQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegUnitOfMeasureQty.new", 
    "    LegUnitOfMeasureQty.new()\n"
    "    LegUnitOfMeasureQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegUnitOfMeasureQty(FIX::LegUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class SwigClassNoTrdRegTimestamps;

SWIGINTERN VALUE
_wrap_new_NoTrdRegTimestamps__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRegTimestamps";
  FIX::NoTrdRegTimestamps *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoTrdRegTimestamps *)new FIX::NoTrdRegTimestamps();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoTrdRegTimestamps_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoTrdRegTimestamps_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoTrdRegTimestamps);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoTrdRegTimestamps__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRegTimestamps";
  FIX::NoTrdRegTimestamps *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoTrdRegTimestamps", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoTrdRegTimestamps", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoTrdRegTimestamps *)new FIX::NoTrdRegTimestamps((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoTrdRegTimestamps(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoTrdRegTimestamps__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTrdRegTimestamps__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoTrdRegTimestamps.new", 
    "    NoTrdRegTimestamps.new()\n"
    "    NoTrdRegTimestamps.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTrdRegTimestamps(FIX::NoTrdRegTimestamps *arg1) {
    delete arg1;
}

swig_class SwigClassSendingDate;

SWIGINTERN VALUE
_wrap_new_SendingDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SendingDate";
  FIX::SendingDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SendingDate *)new FIX::SendingDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SendingDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SendingDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SendingDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SendingDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingDate";
  FIX::SendingDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::SendingDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::SendingDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::SendingDate *)new FIX::SendingDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SendingDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SendingDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SendingDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SendingDate.new", 
    "    SendingDate.new()\n"
    "    SendingDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SendingDate(FIX::SendingDate *arg1) {
    delete arg1;
}

swig_class SwigClassTimeToExpiration;

SWIGINTERN VALUE
_wrap_new_TimeToExpiration__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TimeToExpiration";
  FIX::TimeToExpiration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TimeToExpiration *)new FIX::TimeToExpiration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TimeToExpiration_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TimeToExpiration_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TimeToExpiration);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TimeToExpiration__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeToExpiration";
  FIX::TimeToExpiration *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::TimeToExpiration", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::TimeToExpiration", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::TimeToExpiration *)new FIX::TimeToExpiration((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TimeToExpiration(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TimeToExpiration__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeToExpiration__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TimeToExpiration.new", 
    "    TimeToExpiration.new()\n"
    "    TimeToExpiration.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeToExpiration(FIX::TimeToExpiration *arg1) {
    delete arg1;
}

swig_class SwigClassLegAllocQty;

SWIGINTERN VALUE
_wrap_new_LegAllocQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegAllocQty";
  FIX::LegAllocQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegAllocQty *)new FIX::LegAllocQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegAllocQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegAllocQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegAllocQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegAllocQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocQty";
  FIX::LegAllocQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::LegAllocQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::LegAllocQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::LegAllocQty *)new FIX::LegAllocQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegAllocQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegAllocQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegAllocQty.new", 
    "    LegAllocQty.new()\n"
    "    LegAllocQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocQty(FIX::LegAllocQty *arg1) {
    delete arg1;
}

swig_class SwigClassSettlLocation;

SWIGINTERN VALUE
_wrap_new_SettlLocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlLocation";
  FIX::SettlLocation *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlLocation *)new FIX::SettlLocation();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlLocation_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlLocation_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlLocation);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlLocation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlLocation";
  FIX::SettlLocation *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SettlLocation", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SettlLocation", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SettlLocation *)new FIX::SettlLocation((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlLocation(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlLocation__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlLocation__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlLocation.new", 
    "    SettlLocation.new()\n"
    "    SettlLocation.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlLocation(FIX::SettlLocation *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingExerciseStyle;

SWIGINTERN VALUE
_wrap_new_UnderlyingExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingExerciseStyle";
  FIX::UnderlyingExerciseStyle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingExerciseStyle *)new FIX::UnderlyingExerciseStyle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingExerciseStyle_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingExerciseStyle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingExerciseStyle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingExerciseStyle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingExerciseStyle";
  FIX::UnderlyingExerciseStyle *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingExerciseStyle", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingExerciseStyle", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingExerciseStyle *)new FIX::UnderlyingExerciseStyle((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingExerciseStyle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingExerciseStyle__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingExerciseStyle__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingExerciseStyle.new", 
    "    UnderlyingExerciseStyle.new()\n"
    "    UnderlyingExerciseStyle.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingExerciseStyle(FIX::UnderlyingExerciseStyle *arg1) {
    delete arg1;
}

swig_class SwigClassCashSettlAgentContactName;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentContactName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactName";
  FIX::CashSettlAgentContactName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CashSettlAgentContactName *)new FIX::CashSettlAgentContactName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CashSettlAgentContactName_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CashSettlAgentContactName_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CashSettlAgentContactName);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CashSettlAgentContactName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactName";
  FIX::CashSettlAgentContactName *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::CashSettlAgentContactName", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::CashSettlAgentContactName", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::CashSettlAgentContactName *)new FIX::CashSettlAgentContactName((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CashSettlAgentContactName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CashSettlAgentContactName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentContactName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CashSettlAgentContactName.new", 
    "    CashSettlAgentContactName.new()\n"
    "    CashSettlAgentContactName.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentContactName(FIX::CashSettlAgentContactName *arg1) {
    delete arg1;
}

swig_class SwigClassLegRepurchaseRate;

SWIGINTERN VALUE
_wrap_new_LegRepurchaseRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseRate";
  FIX::LegRepurchaseRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegRepurchaseRate *)new FIX::LegRepurchaseRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegRepurchaseRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegRepurchaseRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegRepurchaseRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegRepurchaseRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseRate";
  FIX::LegRepurchaseRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::LegRepurchaseRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::LegRepurchaseRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::LegRepurchaseRate *)new FIX::LegRepurchaseRate((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegRepurchaseRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegRepurchaseRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepurchaseRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegRepurchaseRate.new", 
    "    LegRepurchaseRate.new()\n"
    "    LegRepurchaseRate.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRepurchaseRate(FIX::LegRepurchaseRate *arg1) {
    delete arg1;
}

swig_class SwigClassApplResponseID;

SWIGINTERN VALUE
_wrap_new_ApplResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseID";
  FIX::ApplResponseID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplResponseID *)new FIX::ApplResponseID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplResponseID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplResponseID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplResponseID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplResponseID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseID";
  FIX::ApplResponseID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ApplResponseID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ApplResponseID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ApplResponseID *)new FIX::ApplResponseID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplResponseID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplResponseID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResponseID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplResponseID.new", 
    "    ApplResponseID.new()\n"
    "    ApplResponseID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResponseID(FIX::ApplResponseID *arg1) {
    delete arg1;
}

swig_class SwigClassNoDerivativeInstrAttrib;

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrAttrib__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrAttrib";
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoDerivativeInstrAttrib *)new FIX::NoDerivativeInstrAttrib();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoDerivativeInstrAttrib_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoDerivativeInstrAttrib_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoDerivativeInstrAttrib);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrAttrib__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrAttrib";
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoDerivativeInstrAttrib", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoDerivativeInstrAttrib", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoDerivativeInstrAttrib *)new FIX::NoDerivativeInstrAttrib((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoDerivativeInstrAttrib(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoDerivativeInstrAttrib__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeInstrAttrib__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoDerivativeInstrAttrib.new", 
    "    NoDerivativeInstrAttrib.new()\n"
    "    NoDerivativeInstrAttrib.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeInstrAttrib(FIX::NoDerivativeInstrAttrib *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeStrikeMultiplier;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeMultiplier";
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeStrikeMultiplier *)new FIX::DerivativeStrikeMultiplier();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeStrikeMultiplier_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeStrikeMultiplier_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeStrikeMultiplier);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeMultiplier";
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::DerivativeStrikeMultiplier", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::DerivativeStrikeMultiplier", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::DerivativeStrikeMultiplier *)new FIX::DerivativeStrikeMultiplier((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeStrikeMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeStrikeMultiplier__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikeMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeStrikeMultiplier.new", 
    "    DerivativeStrikeMultiplier.new()\n"
    "    DerivativeStrikeMultiplier.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikeMultiplier(FIX::DerivativeStrikeMultiplier *arg1) {
    delete arg1;
}

swig_class SwigClassLegStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_LegStrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegStrikeCurrency";
  FIX::LegStrikeCurrency *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegStrikeCurrency *)new FIX::LegStrikeCurrency();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegStrikeCurrency_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegStrikeCurrency_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegStrikeCurrency);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegStrikeCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStrikeCurrency";
  FIX::LegStrikeCurrency *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CURRENCY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CURRENCY const &","FIX::LegStrikeCurrency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CURRENCY const &","FIX::LegStrikeCurrency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::LegStrikeCurrency *)new FIX::LegStrikeCurrency((FIX::CURRENCY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegStrikeCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegStrikeCurrency__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStrikeCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegStrikeCurrency.new", 
    "    LegStrikeCurrency.new()\n"
    "    LegStrikeCurrency.new(FIX::CURRENCY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStrikeCurrency(FIX::LegStrikeCurrency *arg1) {
    delete arg1;
}

swig_class SwigClassSecurityStatusReqID;

SWIGINTERN VALUE
_wrap_new_SecurityStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatusReqID";
  FIX::SecurityStatusReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecurityStatusReqID *)new FIX::SecurityStatusReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecurityStatusReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecurityStatusReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecurityStatusReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecurityStatusReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatusReqID";
  FIX::SecurityStatusReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecurityStatusReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecurityStatusReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecurityStatusReqID *)new FIX::SecurityStatusReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecurityStatusReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecurityStatusReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityStatusReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecurityStatusReqID.new", 
    "    SecurityStatusReqID.new()\n"
    "    SecurityStatusReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityStatusReqID(FIX::SecurityStatusReqID *arg1) {
    delete arg1;
}

swig_class SwigClassSecureDataLen;

SWIGINTERN VALUE
_wrap_new_SecureDataLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecureDataLen";
  FIX::SecureDataLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecureDataLen *)new FIX::SecureDataLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecureDataLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecureDataLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecureDataLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecureDataLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecureDataLen";
  FIX::SecureDataLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::SecureDataLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::SecureDataLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::SecureDataLen *)new FIX::SecureDataLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecureDataLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecureDataLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecureDataLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecureDataLen.new", 
    "    SecureDataLen.new()\n"
    "    SecureDataLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecureDataLen(FIX::SecureDataLen *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionScope;

SWIGINTERN VALUE
_wrap_new_DiscretionScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionScope";
  FIX::DiscretionScope *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionScope *)new FIX::DiscretionScope();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionScope_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionScope_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionScope);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionScope__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionScope";
  FIX::DiscretionScope *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DiscretionScope", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DiscretionScope", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DiscretionScope *)new FIX::DiscretionScope((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionScope(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionScope__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionScope__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionScope.new", 
    "    DiscretionScope.new()\n"
    "    DiscretionScope.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionScope(FIX::DiscretionScope *arg1) {
    delete arg1;
}

swig_class SwigClassOwnerType;

SWIGINTERN VALUE
_wrap_new_OwnerType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OwnerType";
  FIX::OwnerType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OwnerType *)new FIX::OwnerType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OwnerType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OwnerType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OwnerType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OwnerType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OwnerType";
  FIX::OwnerType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::OwnerType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::OwnerType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::OwnerType *)new FIX::OwnerType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OwnerType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OwnerType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OwnerType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OwnerType.new", 
    "    OwnerType.new()\n"
    "    OwnerType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OwnerType(FIX::OwnerType *arg1) {
    delete arg1;
}

swig_class SwigClassShares;

SWIGINTERN VALUE
_wrap_new_Shares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Shares";
  FIX::Shares *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Shares *)new FIX::Shares();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Shares_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Shares_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Shares);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Shares__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Shares";
  FIX::Shares *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::Shares", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::Shares", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::Shares *)new FIX::Shares((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Shares(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Shares__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Shares__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Shares.new", 
    "    Shares.new()\n"
    "    Shares.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Shares(FIX::Shares *arg1) {
    delete arg1;
}

swig_class SwigClassYield;

SWIGINTERN VALUE
_wrap_new_Yield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Yield";
  FIX::Yield *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Yield *)new FIX::Yield();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Yield_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Yield_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Yield);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Yield__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Yield";
  FIX::Yield *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::Yield", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::Yield", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::Yield *)new FIX::Yield((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Yield(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Yield__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Yield__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Yield.new", 
    "    Yield.new()\n"
    "    Yield.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Yield(FIX::Yield *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteRespID;

SWIGINTERN VALUE
_wrap_new_QuoteRespID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespID";
  FIX::QuoteRespID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteRespID *)new FIX::QuoteRespID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteRespID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteRespID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteRespID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteRespID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespID";
  FIX::QuoteRespID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::QuoteRespID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::QuoteRespID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::QuoteRespID *)new FIX::QuoteRespID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteRespID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteRespID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRespID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteRespID.new", 
    "    QuoteRespID.new()\n"
    "    QuoteRespID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRespID(FIX::QuoteRespID *arg1) {
    delete arg1;
}

swig_class SwigClassNested3PartySubID;

SWIGINTERN VALUE
_wrap_new_Nested3PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubID";
  FIX::Nested3PartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested3PartySubID *)new FIX::Nested3PartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested3PartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested3PartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested3PartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested3PartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubID";
  FIX::Nested3PartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Nested3PartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Nested3PartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Nested3PartySubID *)new FIX::Nested3PartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested3PartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested3PartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested3PartySubID.new", 
    "    Nested3PartySubID.new()\n"
    "    Nested3PartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartySubID(FIX::Nested3PartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassApplQueueResolution;

SWIGINTERN VALUE
_wrap_new_ApplQueueResolution__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueResolution";
  FIX::ApplQueueResolution *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplQueueResolution *)new FIX::ApplQueueResolution();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplQueueResolution_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplQueueResolution_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplQueueResolution);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplQueueResolution__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueResolution";
  FIX::ApplQueueResolution *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplQueueResolution", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplQueueResolution", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplQueueResolution *)new FIX::ApplQueueResolution((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplQueueResolution(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplQueueResolution__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueResolution__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplQueueResolution.new", 
    "    ApplQueueResolution.new()\n"
    "    ApplQueueResolution.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueResolution(FIX::ApplQueueResolution *arg1) {
    delete arg1;
}

swig_class SwigClassTrdRegTimestampOrigin;

SWIGINTERN VALUE
_wrap_new_TrdRegTimestampOrigin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampOrigin";
  FIX::TrdRegTimestampOrigin *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TrdRegTimestampOrigin *)new FIX::TrdRegTimestampOrigin();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TrdRegTimestampOrigin_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TrdRegTimestampOrigin_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TrdRegTimestampOrigin);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TrdRegTimestampOrigin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampOrigin";
  FIX::TrdRegTimestampOrigin *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TrdRegTimestampOrigin", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TrdRegTimestampOrigin", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TrdRegTimestampOrigin *)new FIX::TrdRegTimestampOrigin((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TrdRegTimestampOrigin(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TrdRegTimestampOrigin__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRegTimestampOrigin__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TrdRegTimestampOrigin.new", 
    "    TrdRegTimestampOrigin.new()\n"
    "    TrdRegTimestampOrigin.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRegTimestampOrigin(FIX::TrdRegTimestampOrigin *arg1) {
    delete arg1;
}

swig_class SwigClassNested2PartyRole;

SWIGINTERN VALUE
_wrap_new_Nested2PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyRole";
  FIX::Nested2PartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested2PartyRole *)new FIX::Nested2PartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested2PartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested2PartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested2PartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested2PartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyRole";
  FIX::Nested2PartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::Nested2PartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::Nested2PartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::Nested2PartyRole *)new FIX::Nested2PartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested2PartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested2PartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested2PartyRole.new", 
    "    Nested2PartyRole.new()\n"
    "    Nested2PartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartyRole(FIX::Nested2PartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassNested2PartyID;

SWIGINTERN VALUE
_wrap_new_Nested2PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyID";
  FIX::Nested2PartyID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Nested2PartyID *)new FIX::Nested2PartyID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Nested2PartyID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Nested2PartyID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Nested2PartyID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Nested2PartyID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyID";
  FIX::Nested2PartyID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::Nested2PartyID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::Nested2PartyID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::Nested2PartyID *)new FIX::Nested2PartyID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Nested2PartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Nested2PartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Nested2PartyID.new", 
    "    Nested2PartyID.new()\n"
    "    Nested2PartyID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartyID(FIX::Nested2PartyID *arg1) {
    delete arg1;
}

swig_class SwigClassBidSize;

SWIGINTERN VALUE
_wrap_new_BidSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidSize";
  FIX::BidSize *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidSize *)new FIX::BidSize();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidSize_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidSize_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidSize);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSize";
  FIX::BidSize *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::BidSize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::BidSize", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::BidSize *)new FIX::BidSize((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidSize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidSize__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidSize__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidSize.new", 
    "    BidSize.new()\n"
    "    BidSize.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidSize(FIX::BidSize *arg1) {
    delete arg1;
}

swig_class SwigClassLegSymbolSfx;

SWIGINTERN VALUE
_wrap_new_LegSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegSymbolSfx";
  FIX::LegSymbolSfx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegSymbolSfx *)new FIX::LegSymbolSfx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegSymbolSfx_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegSymbolSfx_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegSymbolSfx);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegSymbolSfx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSymbolSfx";
  FIX::LegSymbolSfx *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::LegSymbolSfx", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::LegSymbolSfx", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::LegSymbolSfx *)new FIX::LegSymbolSfx((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegSymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegSymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegSymbolSfx.new", 
    "    LegSymbolSfx.new()\n"
    "    LegSymbolSfx.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSymbolSfx(FIX::LegSymbolSfx *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteResponseLevel;

SWIGINTERN VALUE
_wrap_new_QuoteResponseLevel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteResponseLevel";
  FIX::QuoteResponseLevel *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteResponseLevel *)new FIX::QuoteResponseLevel();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteResponseLevel_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteResponseLevel_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteResponseLevel);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteResponseLevel__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteResponseLevel";
  FIX::QuoteResponseLevel *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteResponseLevel", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteResponseLevel", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteResponseLevel *)new FIX::QuoteResponseLevel((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteResponseLevel(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteResponseLevel__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteResponseLevel__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteResponseLevel.new", 
    "    QuoteResponseLevel.new()\n"
    "    QuoteResponseLevel.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteResponseLevel(FIX::QuoteResponseLevel *arg1) {
    delete arg1;
}

swig_class SwigClassBodyLength;

SWIGINTERN VALUE
_wrap_new_BodyLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BodyLength";
  FIX::BodyLength *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BodyLength *)new FIX::BodyLength();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BodyLength_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BodyLength_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BodyLength);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BodyLength__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BodyLength";
  FIX::BodyLength *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::BodyLength", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::BodyLength", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::BodyLength *)new FIX::BodyLength((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BodyLength(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BodyLength__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BodyLength__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BodyLength.new", 
    "    BodyLength.new()\n"
    "    BodyLength.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BodyLength(FIX::BodyLength *arg1) {
    delete arg1;
}

swig_class SwigClassListExecInst;

SWIGINTERN VALUE
_wrap_new_ListExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ListExecInst";
  FIX::ListExecInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ListExecInst *)new FIX::ListExecInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ListExecInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ListExecInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ListExecInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ListExecInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListExecInst";
  FIX::ListExecInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ListExecInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ListExecInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ListExecInst *)new FIX::ListExecInst((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ListExecInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ListExecInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListExecInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ListExecInst.new", 
    "    ListExecInst.new()\n"
    "    ListExecInst.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ListExecInst(FIX::ListExecInst *arg1) {
    delete arg1;
}

swig_class SwigClassExecAckStatus;

SWIGINTERN VALUE
_wrap_new_ExecAckStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecAckStatus";
  FIX::ExecAckStatus *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecAckStatus *)new FIX::ExecAckStatus();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecAckStatus_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecAckStatus_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecAckStatus);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecAckStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecAckStatus";
  FIX::ExecAckStatus *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::ExecAckStatus", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::ExecAckStatus", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ExecAckStatus *)new FIX::ExecAckStatus((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecAckStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecAckStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecAckStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecAckStatus.new", 
    "    ExecAckStatus.new()\n"
    "    ExecAckStatus.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecAckStatus(FIX::ExecAckStatus *arg1) {
    delete arg1;
}

swig_class SwigClassSettlDate2;

SWIGINTERN VALUE
_wrap_new_SettlDate2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlDate2";
  FIX::SettlDate2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlDate2 *)new FIX::SettlDate2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlDate2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlDate2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlDate2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlDate2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDate2";
  FIX::SettlDate2 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::SettlDate2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::SettlDate2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::SettlDate2 *)new FIX::SettlDate2((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlDate2(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlDate2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDate2__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlDate2.new", 
    "    SettlDate2.new()\n"
    "    SettlDate2.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDate2(FIX::SettlDate2 *arg1) {
    delete arg1;
}

swig_class SwigClassNetGrossInd;

SWIGINTERN VALUE
_wrap_new_NetGrossInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetGrossInd";
  FIX::NetGrossInd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetGrossInd *)new FIX::NetGrossInd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetGrossInd_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetGrossInd_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetGrossInd);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetGrossInd__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetGrossInd";
  FIX::NetGrossInd *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NetGrossInd", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NetGrossInd", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NetGrossInd *)new FIX::NetGrossInd((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetGrossInd(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetGrossInd__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetGrossInd__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetGrossInd.new", 
    "    NetGrossInd.new()\n"
    "    NetGrossInd.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetGrossInd(FIX::NetGrossInd *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltIDSource";
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingSecurityAltIDSource *)new FIX::UnderlyingSecurityAltIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingSecurityAltIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingSecurityAltIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltIDSource";
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingSecurityAltIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingSecurityAltIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingSecurityAltIDSource *)new FIX::UnderlyingSecurityAltIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingSecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingSecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingSecurityAltIDSource.new", 
    "    UnderlyingSecurityAltIDSource.new()\n"
    "    UnderlyingSecurityAltIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityAltIDSource(FIX::UnderlyingSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassTestReqID;

SWIGINTERN VALUE
_wrap_new_TestReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TestReqID";
  FIX::TestReqID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TestReqID *)new FIX::TestReqID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TestReqID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TestReqID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TestReqID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TestReqID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TestReqID";
  FIX::TestReqID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TestReqID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TestReqID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TestReqID *)new FIX::TestReqID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TestReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TestReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TestReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TestReqID.new", 
    "    TestReqID.new()\n"
    "    TestReqID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TestReqID(FIX::TestReqID *arg1) {
    delete arg1;
}

swig_class SwigClassCxlType;

SWIGINTERN VALUE
_wrap_new_CxlType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CxlType";
  FIX::CxlType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CxlType *)new FIX::CxlType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CxlType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CxlType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CxlType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CxlType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlType";
  FIX::CxlType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::CxlType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::CxlType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::CxlType *)new FIX::CxlType((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CxlType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CxlType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CxlType.new", 
    "    CxlType.new()\n"
    "    CxlType.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlType(FIX::CxlType *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCreditRating;

SWIGINTERN VALUE
_wrap_new_UnderlyingCreditRating__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCreditRating";
  FIX::UnderlyingCreditRating *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCreditRating *)new FIX::UnderlyingCreditRating();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCreditRating_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCreditRating_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCreditRating);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCreditRating__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCreditRating";
  FIX::UnderlyingCreditRating *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingCreditRating", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingCreditRating", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingCreditRating *)new FIX::UnderlyingCreditRating((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCreditRating(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCreditRating__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCreditRating__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCreditRating.new", 
    "    UnderlyingCreditRating.new()\n"
    "    UnderlyingCreditRating.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCreditRating(FIX::UnderlyingCreditRating *arg1) {
    delete arg1;
}

swig_class SwigClassAvgPxPrecision;

SWIGINTERN VALUE
_wrap_new_AvgPxPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AvgPxPrecision";
  FIX::AvgPxPrecision *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AvgPxPrecision *)new FIX::AvgPxPrecision();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AvgPxPrecision_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AvgPxPrecision_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AvgPxPrecision);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AvgPxPrecision__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPxPrecision";
  FIX::AvgPxPrecision *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::AvgPxPrecision", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::AvgPxPrecision", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::AvgPxPrecision *)new FIX::AvgPxPrecision((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AvgPxPrecision(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AvgPxPrecision__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPxPrecision__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AvgPxPrecision.new", 
    "    AvgPxPrecision.new()\n"
    "    AvgPxPrecision.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPxPrecision(FIX::AvgPxPrecision *arg1) {
    delete arg1;
}

swig_class SwigClassBenchmarkPriceType;

SWIGINTERN VALUE
_wrap_new_BenchmarkPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPriceType";
  FIX::BenchmarkPriceType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BenchmarkPriceType *)new FIX::BenchmarkPriceType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BenchmarkPriceType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BenchmarkPriceType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BenchmarkPriceType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BenchmarkPriceType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPriceType";
  FIX::BenchmarkPriceType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::BenchmarkPriceType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::BenchmarkPriceType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::BenchmarkPriceType *)new FIX::BenchmarkPriceType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BenchmarkPriceType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BenchmarkPriceType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkPriceType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BenchmarkPriceType.new", 
    "    BenchmarkPriceType.new()\n"
    "    BenchmarkPriceType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkPriceType(FIX::BenchmarkPriceType *arg1) {
    delete arg1;
}

swig_class SwigClassDeskTypeSource;

SWIGINTERN VALUE
_wrap_new_DeskTypeSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DeskTypeSource";
  FIX::DeskTypeSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DeskTypeSource *)new FIX::DeskTypeSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DeskTypeSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DeskTypeSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DeskTypeSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DeskTypeSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskTypeSource";
  FIX::DeskTypeSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DeskTypeSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DeskTypeSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DeskTypeSource *)new FIX::DeskTypeSource((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeskTypeSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DeskTypeSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskTypeSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DeskTypeSource.new", 
    "    DeskTypeSource.new()\n"
    "    DeskTypeSource.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskTypeSource(FIX::DeskTypeSource *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionRoundDirection;

SWIGINTERN VALUE
_wrap_new_DiscretionRoundDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionRoundDirection";
  FIX::DiscretionRoundDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionRoundDirection *)new FIX::DiscretionRoundDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionRoundDirection_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionRoundDirection_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionRoundDirection);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionRoundDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionRoundDirection";
  FIX::DiscretionRoundDirection *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DiscretionRoundDirection", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DiscretionRoundDirection", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DiscretionRoundDirection *)new FIX::DiscretionRoundDirection((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionRoundDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionRoundDirection__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionRoundDirection__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionRoundDirection.new", 
    "    DiscretionRoundDirection.new()\n"
    "    DiscretionRoundDirection.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionRoundDirection(FIX::DiscretionRoundDirection *arg1) {
    delete arg1;
}

swig_class SwigClassOrigSecondaryTradeID;

SWIGINTERN VALUE
_wrap_new_OrigSecondaryTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrigSecondaryTradeID";
  FIX::OrigSecondaryTradeID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrigSecondaryTradeID *)new FIX::OrigSecondaryTradeID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrigSecondaryTradeID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrigSecondaryTradeID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrigSecondaryTradeID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrigSecondaryTradeID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSecondaryTradeID";
  FIX::OrigSecondaryTradeID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::OrigSecondaryTradeID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::OrigSecondaryTradeID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::OrigSecondaryTradeID *)new FIX::OrigSecondaryTradeID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrigSecondaryTradeID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrigSecondaryTradeID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigSecondaryTradeID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrigSecondaryTradeID.new", 
    "    OrigSecondaryTradeID.new()\n"
    "    OrigSecondaryTradeID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigSecondaryTradeID(FIX::OrigSecondaryTradeID *arg1) {
    delete arg1;
}

swig_class SwigClassReceivedDeptID;

SWIGINTERN VALUE
_wrap_new_ReceivedDeptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ReceivedDeptID";
  FIX::ReceivedDeptID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ReceivedDeptID *)new FIX::ReceivedDeptID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ReceivedDeptID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ReceivedDeptID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ReceivedDeptID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ReceivedDeptID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReceivedDeptID";
  FIX::ReceivedDeptID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::ReceivedDeptID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::ReceivedDeptID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::ReceivedDeptID *)new FIX::ReceivedDeptID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ReceivedDeptID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ReceivedDeptID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReceivedDeptID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ReceivedDeptID.new", 
    "    ReceivedDeptID.new()\n"
    "    ReceivedDeptID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ReceivedDeptID(FIX::ReceivedDeptID *arg1) {
    delete arg1;
}

swig_class SwigClassMaturityNetMoney;

SWIGINTERN VALUE
_wrap_new_MaturityNetMoney__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MaturityNetMoney";
  FIX::MaturityNetMoney *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MaturityNetMoney *)new FIX::MaturityNetMoney();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MaturityNetMoney_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MaturityNetMoney_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MaturityNetMoney);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MaturityNetMoney__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityNetMoney";
  FIX::MaturityNetMoney *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__AMT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::AMT const &","FIX::MaturityNetMoney", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::AMT const &","FIX::MaturityNetMoney", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::MaturityNetMoney *)new FIX::MaturityNetMoney((FIX::AMT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaturityNetMoney(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MaturityNetMoney__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityNetMoney__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaturityNetMoney.new", 
    "    MaturityNetMoney.new()\n"
    "    MaturityNetMoney.new(FIX::AMT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityNetMoney(FIX::MaturityNetMoney *arg1) {
    delete arg1;
}

swig_class SwigClassBidDescriptorType;

SWIGINTERN VALUE
_wrap_new_BidDescriptorType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptorType";
  FIX::BidDescriptorType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BidDescriptorType *)new FIX::BidDescriptorType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BidDescriptorType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BidDescriptorType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BidDescriptorType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BidDescriptorType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptorType";
  FIX::BidDescriptorType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::BidDescriptorType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::BidDescriptorType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::BidDescriptorType *)new FIX::BidDescriptorType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BidDescriptorType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BidDescriptorType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidDescriptorType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BidDescriptorType.new", 
    "    BidDescriptorType.new()\n"
    "    BidDescriptorType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BidDescriptorType(FIX::BidDescriptorType *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativeInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubID";
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativeInstrumentPartySubID *)new FIX::DerivativeInstrumentPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativeInstrumentPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativeInstrumentPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubID";
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::DerivativeInstrumentPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::DerivativeInstrumentPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::DerivativeInstrumentPartySubID *)new FIX::DerivativeInstrumentPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativeInstrumentPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeInstrumentPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativeInstrumentPartySubID.new", 
    "    DerivativeInstrumentPartySubID.new()\n"
    "    DerivativeInstrumentPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartySubID(FIX::DerivativeInstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassNetworkStatusResponseType;

SWIGINTERN VALUE
_wrap_new_NetworkStatusResponseType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NetworkStatusResponseType";
  FIX::NetworkStatusResponseType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NetworkStatusResponseType *)new FIX::NetworkStatusResponseType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NetworkStatusResponseType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NetworkStatusResponseType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NetworkStatusResponseType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NetworkStatusResponseType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkStatusResponseType";
  FIX::NetworkStatusResponseType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::NetworkStatusResponseType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::NetworkStatusResponseType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NetworkStatusResponseType *)new FIX::NetworkStatusResponseType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NetworkStatusResponseType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NetworkStatusResponseType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkStatusResponseType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NetworkStatusResponseType.new", 
    "    NetworkStatusResponseType.new()\n"
    "    NetworkStatusResponseType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkStatusResponseType(FIX::NetworkStatusResponseType *arg1) {
    delete arg1;
}

swig_class SwigClassDateOfBirth;

SWIGINTERN VALUE
_wrap_new_DateOfBirth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DateOfBirth";
  FIX::DateOfBirth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DateOfBirth *)new FIX::DateOfBirth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DateOfBirth_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DateOfBirth_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DateOfBirth);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DateOfBirth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DateOfBirth";
  FIX::DateOfBirth *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::DateOfBirth", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::DateOfBirth", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::DateOfBirth *)new FIX::DateOfBirth((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DateOfBirth(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DateOfBirth__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DateOfBirth__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DateOfBirth.new", 
    "    DateOfBirth.new()\n"
    "    DateOfBirth.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DateOfBirth(FIX::DateOfBirth *arg1) {
    delete arg1;
}

swig_class SwigClassStartStrikePxRange;

SWIGINTERN VALUE
_wrap_new_StartStrikePxRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StartStrikePxRange";
  FIX::StartStrikePxRange *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StartStrikePxRange *)new FIX::StartStrikePxRange();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StartStrikePxRange_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StartStrikePxRange_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StartStrikePxRange);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StartStrikePxRange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PRICE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartStrikePxRange";
  FIX::StartStrikePxRange *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PRICE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PRICE const &","FIX::StartStrikePxRange", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PRICE const &","FIX::StartStrikePxRange", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  result = (FIX::StartStrikePxRange *)new FIX::StartStrikePxRange((FIX::PRICE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StartStrikePxRange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StartStrikePxRange__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartStrikePxRange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StartStrikePxRange.new", 
    "    StartStrikePxRange.new()\n"
    "    StartStrikePxRange.new(FIX::PRICE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StartStrikePxRange(FIX::StartStrikePxRange *arg1) {
    delete arg1;
}

swig_class SwigClassUndlyInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubID";
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UndlyInstrumentPartySubID *)new FIX::UndlyInstrumentPartySubID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UndlyInstrumentPartySubID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UndlyInstrumentPartySubID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UndlyInstrumentPartySubID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartySubID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubID";
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UndlyInstrumentPartySubID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UndlyInstrumentPartySubID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UndlyInstrumentPartySubID *)new FIX::UndlyInstrumentPartySubID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UndlyInstrumentPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UndlyInstrumentPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UndlyInstrumentPartySubID.new", 
    "    UndlyInstrumentPartySubID.new()\n"
    "    UndlyInstrumentPartySubID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartySubID(FIX::UndlyInstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class SwigClassSecondaryTradeReportRefID;

SWIGINTERN VALUE
_wrap_new_SecondaryTradeReportRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportRefID";
  FIX::SecondaryTradeReportRefID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SecondaryTradeReportRefID *)new FIX::SecondaryTradeReportRefID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SecondaryTradeReportRefID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SecondaryTradeReportRefID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SecondaryTradeReportRefID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SecondaryTradeReportRefID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportRefID";
  FIX::SecondaryTradeReportRefID *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::SecondaryTradeReportRefID", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::SecondaryTradeReportRefID", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::SecondaryTradeReportRefID *)new FIX::SecondaryTradeReportRefID((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SecondaryTradeReportRefID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecondaryTradeReportRefID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradeReportRefID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SecondaryTradeReportRefID.new", 
    "    SecondaryTradeReportRefID.new()\n"
    "    SecondaryTradeReportRefID.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradeReportRefID(FIX::SecondaryTradeReportRefID *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingCPRegType;

SWIGINTERN VALUE
_wrap_new_UnderlyingCPRegType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPRegType";
  FIX::UnderlyingCPRegType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingCPRegType *)new FIX::UnderlyingCPRegType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingCPRegType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingCPRegType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingCPRegType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingCPRegType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPRegType";
  FIX::UnderlyingCPRegType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingCPRegType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingCPRegType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingCPRegType *)new FIX::UnderlyingCPRegType((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingCPRegType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingCPRegType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCPRegType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingCPRegType.new", 
    "    UnderlyingCPRegType.new()\n"
    "    UnderlyingCPRegType.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCPRegType(FIX::UnderlyingCPRegType *arg1) {
    delete arg1;
}

swig_class SwigClassSignatureLength;

SWIGINTERN VALUE
_wrap_new_SignatureLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SignatureLength";
  FIX::SignatureLength *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SignatureLength *)new FIX::SignatureLength();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SignatureLength_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SignatureLength_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SignatureLength);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SignatureLength__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SignatureLength";
  FIX::SignatureLength *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::SignatureLength", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::SignatureLength", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::SignatureLength *)new FIX::SignatureLength((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SignatureLength(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SignatureLength__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SignatureLength__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SignatureLength.new", 
    "    SignatureLength.new()\n"
    "    SignatureLength.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SignatureLength(FIX::SignatureLength *arg1) {
    delete arg1;
}

swig_class SwigClassOrderQty;

SWIGINTERN VALUE
_wrap_new_OrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OrderQty";
  FIX::OrderQty *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OrderQty *)new FIX::OrderQty();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OrderQty_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OrderQty_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OrderQty);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OrderQty__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::QTY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderQty";
  FIX::OrderQty *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__QTY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::QTY const &","FIX::OrderQty", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::QTY const &","FIX::OrderQty", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  result = (FIX::OrderQty *)new FIX::OrderQty((FIX::QTY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OrderQty(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OrderQty__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderQty__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OrderQty.new", 
    "    OrderQty.new()\n"
    "    OrderQty.new(FIX::QTY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderQty(FIX::OrderQty *arg1) {
    delete arg1;
}

swig_class SwigClassOriginalNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_OriginalNotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::OriginalNotionalPercentageOutstanding";
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::OriginalNotionalPercentageOutstanding *)new FIX::OriginalNotionalPercentageOutstanding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_OriginalNotionalPercentageOutstanding_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_OriginalNotionalPercentageOutstanding_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_OriginalNotionalPercentageOutstanding__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OriginalNotionalPercentageOutstanding";
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PERCENTAGE const &","FIX::OriginalNotionalPercentageOutstanding", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::PERCENTAGE const &","FIX::OriginalNotionalPercentageOutstanding", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::OriginalNotionalPercentageOutstanding *)new FIX::OriginalNotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_OriginalNotionalPercentageOutstanding(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_OriginalNotionalPercentageOutstanding__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OriginalNotionalPercentageOutstanding__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "OriginalNotionalPercentageOutstanding.new", 
    "    OriginalNotionalPercentageOutstanding.new()\n"
    "    OriginalNotionalPercentageOutstanding.new(FIX::PERCENTAGE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_OriginalNotionalPercentageOutstanding(FIX::OriginalNotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingTimeUnit;

SWIGINTERN VALUE
_wrap_new_UnderlyingTimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTimeUnit";
  FIX::UnderlyingTimeUnit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingTimeUnit *)new FIX::UnderlyingTimeUnit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingTimeUnit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingTimeUnit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingTimeUnit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingTimeUnit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTimeUnit";
  FIX::UnderlyingTimeUnit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingTimeUnit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingTimeUnit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingTimeUnit *)new FIX::UnderlyingTimeUnit((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingTimeUnit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingTimeUnit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingTimeUnit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingTimeUnit.new", 
    "    UnderlyingTimeUnit.new()\n"
    "    UnderlyingTimeUnit.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingTimeUnit(FIX::UnderlyingTimeUnit *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedHeadlineLen;

SWIGINTERN VALUE
_wrap_new_EncodedHeadlineLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadlineLen";
  FIX::EncodedHeadlineLen *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedHeadlineLen *)new FIX::EncodedHeadlineLen();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedHeadlineLen_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedHeadlineLen_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedHeadlineLen);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedHeadlineLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadlineLen";
  FIX::EncodedHeadlineLen *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LENGTH,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LENGTH const &","FIX::EncodedHeadlineLen", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LENGTH const &","FIX::EncodedHeadlineLen", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedHeadlineLen *)new FIX::EncodedHeadlineLen((FIX::LENGTH const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedHeadlineLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedHeadlineLen__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedHeadlineLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedHeadlineLen.new", 
    "    EncodedHeadlineLen.new()\n"
    "    EncodedHeadlineLen.new(FIX::LENGTH const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedHeadlineLen(FIX::EncodedHeadlineLen *arg1) {
    delete arg1;
}

swig_class SwigClassNoRegistDtls;

SWIGINTERN VALUE
_wrap_new_NoRegistDtls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoRegistDtls";
  FIX::NoRegistDtls *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoRegistDtls *)new FIX::NoRegistDtls();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoRegistDtls_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoRegistDtls_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoRegistDtls);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoRegistDtls__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRegistDtls";
  FIX::NoRegistDtls *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoRegistDtls", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoRegistDtls", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRegistDtls *)new FIX::NoRegistDtls((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRegistDtls(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRegistDtls__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRegistDtls__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoRegistDtls.new", 
    "    NoRegistDtls.new()\n"
    "    NoRegistDtls.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRegistDtls(FIX::NoRegistDtls *arg1) {
    delete arg1;
}

swig_class SwigClassStrategyParameterValue;

SWIGINTERN VALUE
_wrap_new_StrategyParameterValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterValue";
  FIX::StrategyParameterValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StrategyParameterValue *)new FIX::StrategyParameterValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StrategyParameterValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StrategyParameterValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StrategyParameterValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StrategyParameterValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterValue";
  FIX::StrategyParameterValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StrategyParameterValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StrategyParameterValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StrategyParameterValue *)new FIX::StrategyParameterValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StrategyParameterValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StrategyParameterValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrategyParameterValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StrategyParameterValue.new", 
    "    StrategyParameterValue.new()\n"
    "    StrategyParameterValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StrategyParameterValue(FIX::StrategyParameterValue *arg1) {
    delete arg1;
}

swig_class SwigClassNoInstrumentParties;

SWIGINTERN VALUE
_wrap_new_NoInstrumentParties__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentParties";
  FIX::NoInstrumentParties *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoInstrumentParties *)new FIX::NoInstrumentParties();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoInstrumentParties_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoInstrumentParties_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoInstrumentParties);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoInstrumentParties__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentParties";
  FIX::NoInstrumentParties *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoInstrumentParties", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoInstrumentParties", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoInstrumentParties *)new FIX::NoInstrumentParties((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoInstrumentParties(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoInstrumentParties__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoInstrumentParties__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoInstrumentParties.new", 
    "    NoInstrumentParties.new()\n"
    "    NoInstrumentParties.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoInstrumentParties(FIX::NoInstrumentParties *arg1) {
    delete arg1;
}

swig_class SwigClassQuoteType;

SWIGINTERN VALUE
_wrap_new_QuoteType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::QuoteType";
  FIX::QuoteType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::QuoteType *)new FIX::QuoteType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_QuoteType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_QuoteType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__QuoteType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_QuoteType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteType";
  FIX::QuoteType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::QuoteType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::QuoteType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::QuoteType *)new FIX::QuoteType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_QuoteType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_QuoteType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "QuoteType.new", 
    "    QuoteType.new()\n"
    "    QuoteType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteType(FIX::QuoteType *arg1) {
    delete arg1;
}

swig_class SwigClassNoStrategyParameters;

SWIGINTERN VALUE
_wrap_new_NoStrategyParameters__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NoStrategyParameters";
  FIX::NoStrategyParameters *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NoStrategyParameters *)new FIX::NoStrategyParameters();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NoStrategyParameters_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NoStrategyParameters_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NoStrategyParameters);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NoStrategyParameters__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrategyParameters";
  FIX::NoStrategyParameters *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NUMINGROUP const &","FIX::NoStrategyParameters", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::NUMINGROUP const &","FIX::NoStrategyParameters", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoStrategyParameters *)new FIX::NoStrategyParameters((FIX::NUMINGROUP const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoStrategyParameters(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoStrategyParameters__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStrategyParameters__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NoStrategyParameters.new", 
    "    NoStrategyParameters.new()\n"
    "    NoStrategyParameters.new(FIX::NUMINGROUP const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStrategyParameters(FIX::NoStrategyParameters *arg1) {
    delete arg1;
}

swig_class SwigClassIndividualAllocRejCode;

SWIGINTERN VALUE
_wrap_new_IndividualAllocRejCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocRejCode";
  FIX::IndividualAllocRejCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IndividualAllocRejCode *)new FIX::IndividualAllocRejCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IndividualAllocRejCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IndividualAllocRejCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IndividualAllocRejCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IndividualAllocRejCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocRejCode";
  FIX::IndividualAllocRejCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::IndividualAllocRejCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::IndividualAllocRejCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::IndividualAllocRejCode *)new FIX::IndividualAllocRejCode((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IndividualAllocRejCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IndividualAllocRejCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndividualAllocRejCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IndividualAllocRejCode.new", 
    "    IndividualAllocRejCode.new()\n"
    "    IndividualAllocRejCode.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IndividualAllocRejCode(FIX::IndividualAllocRejCode *arg1) {
    delete arg1;
}

swig_class SwigClassDiscretionInst;

SWIGINTERN VALUE
_wrap_new_DiscretionInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DiscretionInst";
  FIX::DiscretionInst *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DiscretionInst *)new FIX::DiscretionInst();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DiscretionInst_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DiscretionInst_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DiscretionInst);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DiscretionInst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionInst";
  FIX::DiscretionInst *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::DiscretionInst", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::DiscretionInst", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::DiscretionInst *)new FIX::DiscretionInst((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DiscretionInst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DiscretionInst__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionInst__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DiscretionInst.new", 
    "    DiscretionInst.new()\n"
    "    DiscretionInst.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionInst(FIX::DiscretionInst *arg1) {
    delete arg1;
}

swig_class SwigClassTargetPartyRole;

SWIGINTERN VALUE
_wrap_new_TargetPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyRole";
  FIX::TargetPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TargetPartyRole *)new FIX::TargetPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TargetPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TargetPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TargetPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TargetPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyRole";
  FIX::TargetPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::TargetPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::TargetPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::TargetPartyRole *)new FIX::TargetPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TargetPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TargetPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TargetPartyRole.new", 
    "    TargetPartyRole.new()\n"
    "    TargetPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetPartyRole(FIX::TargetPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassCrossPrioritization;

SWIGINTERN VALUE
_wrap_new_CrossPrioritization__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::CrossPrioritization";
  FIX::CrossPrioritization *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::CrossPrioritization *)new FIX::CrossPrioritization();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CrossPrioritization_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CrossPrioritization_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__CrossPrioritization);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CrossPrioritization__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossPrioritization";
  FIX::CrossPrioritization *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::CrossPrioritization", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::CrossPrioritization", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::CrossPrioritization *)new FIX::CrossPrioritization((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CrossPrioritization(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CrossPrioritization__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossPrioritization__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CrossPrioritization.new", 
    "    CrossPrioritization.new()\n"
    "    CrossPrioritization.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossPrioritization(FIX::CrossPrioritization *arg1) {
    delete arg1;
}

swig_class SwigClassEncodedListStatusText;

SWIGINTERN VALUE
_wrap_new_EncodedListStatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusText";
  FIX::EncodedListStatusText *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::EncodedListStatusText *)new FIX::EncodedListStatusText();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_EncodedListStatusText_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_EncodedListStatusText_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__EncodedListStatusText);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_EncodedListStatusText__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusText";
  FIX::EncodedListStatusText *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DATA,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DATA const &","FIX::EncodedListStatusText", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DATA const &","FIX::EncodedListStatusText", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedListStatusText *)new FIX::EncodedListStatusText((FIX::DATA const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedListStatusText(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedListStatusText__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListStatusText__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "EncodedListStatusText.new", 
    "    EncodedListStatusText.new()\n"
    "    EncodedListStatusText.new(FIX::DATA const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListStatusText(FIX::EncodedListStatusText *arg1) {
    delete arg1;
}

swig_class SwigClassIOIOthSvc;

SWIGINTERN VALUE
_wrap_new_IOIOthSvc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::IOIOthSvc";
  FIX::IOIOthSvc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::IOIOthSvc *)new FIX::IOIOthSvc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IOIOthSvc_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IOIOthSvc_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__IOIOthSvc);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IOIOthSvc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIOthSvc";
  FIX::IOIOthSvc *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::IOIOthSvc", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::IOIOthSvc", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::IOIOthSvc *)new FIX::IOIOthSvc((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IOIOthSvc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IOIOthSvc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIOthSvc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "IOIOthSvc.new", 
    "    IOIOthSvc.new()\n"
    "    IOIOthSvc.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIOthSvc(FIX::IOIOthSvc *arg1) {
    delete arg1;
}

swig_class SwigClassLegIssueDate;

SWIGINTERN VALUE
_wrap_new_LegIssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::LegIssueDate";
  FIX::LegIssueDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::LegIssueDate *)new FIX::LegIssueDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LegIssueDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LegIssueDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__LegIssueDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LegIssueDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIssueDate";
  FIX::LegIssueDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::LegIssueDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::LegIssueDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::LegIssueDate *)new FIX::LegIssueDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LegIssueDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_LegIssueDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIssueDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "LegIssueDate.new", 
    "    LegIssueDate.new()\n"
    "    LegIssueDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIssueDate(FIX::LegIssueDate *arg1) {
    delete arg1;
}

swig_class SwigClassMDReqRejReason;

SWIGINTERN VALUE
_wrap_new_MDReqRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MDReqRejReason";
  FIX::MDReqRejReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MDReqRejReason *)new FIX::MDReqRejReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MDReqRejReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MDReqRejReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MDReqRejReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MDReqRejReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReqRejReason";
  FIX::MDReqRejReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__CHAR,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::CHAR const &","FIX::MDReqRejReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::CHAR const &","FIX::MDReqRejReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::MDReqRejReason *)new FIX::MDReqRejReason((FIX::CHAR const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MDReqRejReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MDReqRejReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDReqRejReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MDReqRejReason.new", 
    "    MDReqRejReason.new()\n"
    "    MDReqRejReason.new(FIX::CHAR const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_MDReqRejReason(FIX::MDReqRejReason *arg1) {
    delete arg1;
}

swig_class SwigClassApplReqType;

SWIGINTERN VALUE
_wrap_new_ApplReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ApplReqType";
  FIX::ApplReqType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ApplReqType *)new FIX::ApplReqType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ApplReqType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ApplReqType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ApplReqType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ApplReqType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReqType";
  FIX::ApplReqType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::ApplReqType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::ApplReqType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::ApplReqType *)new FIX::ApplReqType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ApplReqType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ApplReqType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReqType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ApplReqType.new", 
    "    ApplReqType.new()\n"
    "    ApplReqType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReqType(FIX::ApplReqType *arg1) {
    delete arg1;
}

swig_class SwigClassCountry;

SWIGINTERN VALUE
_wrap_new_Country__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Country";
  FIX::Country *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Country *)new FIX::Country();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Country_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Country_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Country);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Country__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Country";
  FIX::Country *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__COUNTRY,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::COUNTRY const &","FIX::Country", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::COUNTRY const &","FIX::Country", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  result = (FIX::Country *)new FIX::Country((FIX::COUNTRY const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Country(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Country__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Country__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Country.new", 
    "    Country.new()\n"
    "    Country.new(FIX::COUNTRY const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Country(FIX::Country *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingLegSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityIDSource";
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingLegSecurityIDSource *)new FIX::UnderlyingLegSecurityIDSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingLegSecurityIDSource_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingLegSecurityIDSource_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityIDSource";
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::UnderlyingLegSecurityIDSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::UnderlyingLegSecurityIDSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::UnderlyingLegSecurityIDSource *)new FIX::UnderlyingLegSecurityIDSource((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingLegSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingLegSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingLegSecurityIDSource.new", 
    "    UnderlyingLegSecurityIDSource.new()\n"
    "    UnderlyingLegSecurityIDSource.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityIDSource(FIX::UnderlyingLegSecurityIDSource *arg1) {
    delete arg1;
}

swig_class SwigClassFlexProductEligibilityIndicator;

SWIGINTERN VALUE
_wrap_new_FlexProductEligibilityIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::FlexProductEligibilityIndicator";
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::FlexProductEligibilityIndicator *)new FIX::FlexProductEligibilityIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FlexProductEligibilityIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FlexProductEligibilityIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FlexProductEligibilityIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FlexProductEligibilityIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlexProductEligibilityIndicator";
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::FlexProductEligibilityIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::FlexProductEligibilityIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::FlexProductEligibilityIndicator *)new FIX::FlexProductEligibilityIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FlexProductEligibilityIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FlexProductEligibilityIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FlexProductEligibilityIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FlexProductEligibilityIndicator.new", 
    "    FlexProductEligibilityIndicator.new()\n"
    "    FlexProductEligibilityIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FlexProductEligibilityIndicator(FIX::FlexProductEligibilityIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassAggressorIndicator;

SWIGINTERN VALUE
_wrap_new_AggressorIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::AggressorIndicator";
  FIX::AggressorIndicator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::AggressorIndicator *)new FIX::AggressorIndicator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_AggressorIndicator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_AggressorIndicator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__AggressorIndicator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_AggressorIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AggressorIndicator";
  FIX::AggressorIndicator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::BOOLEAN const &","FIX::AggressorIndicator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::BOOLEAN const &","FIX::AggressorIndicator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::AggressorIndicator *)new FIX::AggressorIndicator((FIX::BOOLEAN const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AggressorIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AggressorIndicator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AggressorIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AggressorIndicator.new", 
    "    AggressorIndicator.new()\n"
    "    AggressorIndicator.new(FIX::BOOLEAN const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_AggressorIndicator(FIX::AggressorIndicator *arg1) {
    delete arg1;
}

swig_class SwigClassExecPriceAdjustment;

SWIGINTERN VALUE
_wrap_new_ExecPriceAdjustment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceAdjustment";
  FIX::ExecPriceAdjustment *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::ExecPriceAdjustment *)new FIX::ExecPriceAdjustment();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ExecPriceAdjustment_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ExecPriceAdjustment_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ExecPriceAdjustment);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ExecPriceAdjustment__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceAdjustment";
  FIX::ExecPriceAdjustment *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::ExecPriceAdjustment", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::ExecPriceAdjustment", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::ExecPriceAdjustment *)new FIX::ExecPriceAdjustment((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ExecPriceAdjustment(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ExecPriceAdjustment__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecPriceAdjustment__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ExecPriceAdjustment.new", 
    "    ExecPriceAdjustment.new()\n"
    "    ExecPriceAdjustment.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecPriceAdjustment(FIX::ExecPriceAdjustment *arg1) {
    delete arg1;
}

swig_class SwigClassBusinessRejectReason;

SWIGINTERN VALUE
_wrap_new_BusinessRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectReason";
  FIX::BusinessRejectReason *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BusinessRejectReason *)new FIX::BusinessRejectReason();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BusinessRejectReason_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BusinessRejectReason_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BusinessRejectReason);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BusinessRejectReason__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectReason";
  FIX::BusinessRejectReason *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::BusinessRejectReason", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::BusinessRejectReason", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::BusinessRejectReason *)new FIX::BusinessRejectReason((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BusinessRejectReason(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BusinessRejectReason__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BusinessRejectReason__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BusinessRejectReason.new", 
    "    BusinessRejectReason.new()\n"
    "    BusinessRejectReason.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BusinessRejectReason(FIX::BusinessRejectReason *arg1) {
    delete arg1;
}

swig_class SwigClassTradeDate;

SWIGINTERN VALUE
_wrap_new_TradeDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TradeDate";
  FIX::TradeDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TradeDate *)new FIX::TradeDate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TradeDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TradeDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TradeDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TradeDate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeDate";
  FIX::TradeDate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LOCALMKTDATE const &","FIX::TradeDate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LOCALMKTDATE const &","FIX::TradeDate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  result = (FIX::TradeDate *)new FIX::TradeDate((FIX::LOCALMKTDATE const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TradeDate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TradeDate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TradeDate.new", 
    "    TradeDate.new()\n"
    "    TradeDate.new(FIX::LOCALMKTDATE const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeDate(FIX::TradeDate *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingPutOrCall;

SWIGINTERN VALUE
_wrap_new_UnderlyingPutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPutOrCall";
  FIX::UnderlyingPutOrCall *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingPutOrCall *)new FIX::UnderlyingPutOrCall();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingPutOrCall_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingPutOrCall_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingPutOrCall);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingPutOrCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPutOrCall";
  FIX::UnderlyingPutOrCall *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingPutOrCall", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingPutOrCall", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingPutOrCall *)new FIX::UnderlyingPutOrCall((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingPutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingPutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingPutOrCall.new", 
    "    UnderlyingPutOrCall.new()\n"
    "    UnderlyingPutOrCall.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPutOrCall(FIX::UnderlyingPutOrCall *arg1) {
    delete arg1;
}

swig_class SwigClassUnderlyingInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyRole";
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::UnderlyingInstrumentPartyRole *)new FIX::UnderlyingInstrumentPartyRole();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_UnderlyingInstrumentPartyRole_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_UnderlyingInstrumentPartyRole_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyRole__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyRole";
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::UnderlyingInstrumentPartyRole", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::UnderlyingInstrumentPartyRole", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingInstrumentPartyRole *)new FIX::UnderlyingInstrumentPartyRole((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnderlyingInstrumentPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_UnderlyingInstrumentPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UnderlyingInstrumentPartyRole.new", 
    "    UnderlyingInstrumentPartyRole.new()\n"
    "    UnderlyingInstrumentPartyRole.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartyRole(FIX::UnderlyingInstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class SwigClassDerivativePositionLimit;

SWIGINTERN VALUE
_wrap_new_DerivativePositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DerivativePositionLimit";
  FIX::DerivativePositionLimit *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DerivativePositionLimit *)new FIX::DerivativePositionLimit();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DerivativePositionLimit_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DerivativePositionLimit_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DerivativePositionLimit);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DerivativePositionLimit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePositionLimit";
  FIX::DerivativePositionLimit *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::DerivativePositionLimit", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::DerivativePositionLimit", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::DerivativePositionLimit *)new FIX::DerivativePositionLimit((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DerivativePositionLimit(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativePositionLimit__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePositionLimit__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DerivativePositionLimit.new", 
    "    DerivativePositionLimit.new()\n"
    "    DerivativePositionLimit.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePositionLimit(FIX::DerivativePositionLimit *arg1) {
    delete arg1;
}

swig_class SwigClassTierCode;

SWIGINTERN VALUE
_wrap_new_TierCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::TierCode";
  FIX::TierCode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::TierCode *)new FIX::TierCode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TierCode_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TierCode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__TierCode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TierCode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TierCode";
  FIX::TierCode *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::TierCode", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::TierCode", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::TierCode *)new FIX::TierCode((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TierCode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TierCode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TierCode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TierCode.new", 
    "    TierCode.new()\n"
    "    TierCode.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_TierCode(FIX::TierCode *arg1) {
    delete arg1;
}

swig_class SwigClassBookingType;

SWIGINTERN VALUE
_wrap_new_BookingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::BookingType";
  FIX::BookingType *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::BookingType *)new FIX::BookingType();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BookingType_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BookingType_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__BookingType);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BookingType__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::INT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingType";
  FIX::BookingType *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::INT const &","FIX::BookingType", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::INT const &","FIX::BookingType", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::BookingType *)new FIX::BookingType((FIX::INT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BookingType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BookingType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BookingType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "BookingType.new", 
    "    BookingType.new()\n"
    "    BookingType.new(FIX::INT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_BookingType(FIX::BookingType *arg1) {
    delete arg1;
}

swig_class SwigClassStipulationValue;

SWIGINTERN VALUE
_wrap_new_StipulationValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::StipulationValue";
  FIX::StipulationValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::StipulationValue *)new FIX::StipulationValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_StipulationValue_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_StipulationValue_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__StipulationValue);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_StipulationValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::STRING *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StipulationValue";
  FIX::StipulationValue *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::STRING const &","FIX::StipulationValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::STRING const &","FIX::StipulationValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::StipulationValue *)new FIX::StipulationValue((FIX::STRING const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StipulationValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_StipulationValue__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StipulationValue__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "StipulationValue.new", 
    "    StipulationValue.new()\n"
    "    StipulationValue.new(FIX::STRING const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_StipulationValue(FIX::StipulationValue *arg1) {
    delete arg1;
}

swig_class SwigClassSettlCurrBidFxRate;

SWIGINTERN VALUE
_wrap_new_SettlCurrBidFxRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrBidFxRate";
  FIX::SettlCurrBidFxRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SettlCurrBidFxRate *)new FIX::SettlCurrBidFxRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SettlCurrBidFxRate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SettlCurrBidFxRate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SettlCurrBidFxRate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SettlCurrBidFxRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrBidFxRate";
  FIX::SettlCurrBidFxRate *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__FLOAT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FLOAT const &","FIX::SettlCurrBidFxRate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::FLOAT const &","FIX::SettlCurrBidFxRate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::SettlCurrBidFxRate *)new FIX::SettlCurrBidFxRate((FIX::FLOAT const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SettlCurrBidFxRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SettlCurrBidFxRate__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrBidFxRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SettlCurrBidFxRate.new", 
    "    SettlCurrBidFxRate.new()\n"
    "    SettlCurrBidFxRate.new(FIX::FLOAT const &value)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrBidFxRate(FIX::SettlCurrBidFxRate *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BeginString_FIXT11_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIXT11);
  return _val;
}


SWIGINTERN VALUE
_wrap_BeginString_FIX50_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX50);
  return _val;
}


SWIGINTERN VALUE
_wrap_BeginString_FIX44_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX44);
  return _val;
}


SWIGINTERN VALUE
_wrap_BeginString_FIX43_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX43);
  return _val;
}


SWIGINTERN VALUE
_wrap_BeginString_FIX42_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX42);
  return _val;
}


SWIGINTERN VALUE
_wrap_BeginString_FIX41_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX41);
  return _val;
}


SWIGINTERN VALUE
_wrap_BeginString_FIX40_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX40);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_UNDEFINED_TAG_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_UNDEFINED_TAG_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_DECRYPTION_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_SIGNATURE_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_COMPID_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_COMPID_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INVALID_MSGTYPE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_OTHER_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_OTHER_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNKNOWN_ID_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_ID_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_NOT_AUTHORIZED_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryForm_BOOKENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOKENTRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryForm_BEARER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BEARER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryForm_BOOK_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOK_ENTRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_WAREHOUSE_RECAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSE_RECAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_GT_CORPORATE_ACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_CORPORATE_ACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_PEG_REFRESH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PEG_REFRESH));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_CANCELED_NOT_BEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELED_NOT_BEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_CANCEL_ON_TRADING_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_TRADING_HALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_VERBAL_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL_CHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_BROKER_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BROKER_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_REPRICING_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_REPRICING_OF_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecRestatementReason_GT_RENEWAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_RENEWAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocIntermedReqType_PENDING_RELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_RELEASE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocIntermedReqType_PENDING_REVERSAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_REVERSAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCOUNT_LEVEL_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocIntermedReqType_BLOCK_LEVEL_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_BLOCK_LEVEL_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocIntermedReqType_PENDING_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocIntermedReqType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListTypeSource_GICS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_GICS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListTypeSource_NAICS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_NAICS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListTypeSource_ICB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_ICB));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_OUTSTANDING_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDING_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_PARTIALLY_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLY_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_TRADE_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADE_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_FULLY_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLY_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTION_ELIGIBLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_NOT_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOT_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_COLLATERAL_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERAL_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_TRADEDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADEDATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_COLLATERALINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERALINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryQualifier_GC_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GC_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContingencyType_ONE_UPDATES_THE_OTHER_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_UPDATES_THE_OTHER_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContingencyType_ONE_TRIGGERS_THE_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_TRIGGERS_THE_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContingencyType_ONE_CANCELS_THE_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_CANCELS_THE_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContingencyType_ONE_UPDATES_THE_OTHER_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_UPDATES_THE_OTHER_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_EmailType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_EmailType_REPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_REPLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_EmailType_ADMIN_REPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMIN_REPLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQltyInd_MEDIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_MEDIUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQltyInd_HIGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_HIGH));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQltyInd_LOW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_LOW));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_HOUSE_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSE_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_FLOOR_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOOR_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_JOINT_BACK_OFFICE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINT_BACK_OFFICE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_JOINT_BACKOFFICE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINT_BACKOFFICE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonInt_ADDITIONAL_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ADDITIONAL_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonInt_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonInt_ORDER_INFLUX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_INFLUX));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonInt_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_DISSEMINATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonInt_EQUIPMENT_CHANGEOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_EQUIPMENT_CHANGEOVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonInt_ORDER_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_106H_AND_106J_FIRMS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_106H_AND_106J_FIRMS);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_106F_EMPLOYEES);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_CBOE_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOE_MEMBER);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_BidType_DISCLOSED_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_STYLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidType_NO_BIDDING_PROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_NO_BIDDING_PROCESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidType_DISCLOSED_SYTLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_SYTLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidType_NON_DISCLOSED_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_NON_DISCLOSED_STYLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_PER_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PER_SHARE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_PREMIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_TED_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_YIELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_FIXED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXED_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_YIELD_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD_SPREAD));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_TED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_SPREAD));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegPriceMethod_REVERSED_NET_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_REVERSED_NET_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegPriceMethod_MULTIPLIED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_MULTIPLIED_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegPriceMethod_INDIVIDUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_INDIVIDUAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegPriceMethod_YIELD_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_YIELD_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegPriceMethod_NET_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_NET_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListMethod_PRE_LISTED_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListMethod_PRE_LISTED_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListMethod_USER_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListMethod_USER_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDImplicitDelete_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDImplicitDelete_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_RoutingType_TARGET_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_LIST));
  return _val;
}


SWIGINTERN VALUE
_wrap_RoutingType_TARGET_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_RoutingType_BLOCK_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_LIST));
  return _val;
}


SWIGINTERN VALUE
_wrap_RoutingType_BLOCK_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidTradeType_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_AGENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidTradeType_VWAP_GUARANTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAP_GUARANTEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidTradeType_RISK_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISK_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidTradeType_GUARANTEED_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEED_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_ALLOCATED_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_ORDER_EXCEEDS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_ORDER_EXCEEDS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_EXCHANGE_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHANGE_CLOSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_SURVEILLENCE_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_UNKNOWN_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_DUPLICATE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_TOO_LATE_TO_ENTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TOO_LATE_TO_ENTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_INCORRECT_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_INVALID_PRICE_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVALID_PRICE_INCREMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_UNKNOWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_INVALID_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVALID_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_BROKER_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_TRADE_ALONG_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TRADE_ALONG_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdRejReason_STALE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearIncrementUnits_WEEKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_WEEKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearIncrementUnits_MONTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_MONTHS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearIncrementUnits_YEARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_YEARS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearIncrementUnits_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_DAYS));
  return _val;
}


SWIGINTERN VALUE
_wrap_DisplayWhen_EXHAUST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_EXHAUST));
  return _val;
}


SWIGINTERN VALUE
_wrap_DisplayWhen_IMMEDIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_IMMEDIATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueAction_END_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_END_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueAction_QUEUE_FLUSHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUE_FLUSHED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueAction_OVERLAY_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAY_LAST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueAction_NO_ACTION_TAKEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_NO_ACTION_TAKEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_HALFS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_HALFS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PER_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_SHARE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_FOURTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_FOURTHS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_YIELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_TED_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_YIELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PREMIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_FIXED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_EIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_EIGHTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTEENTHS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_PER_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_VARIABLE_CABINET_TRADE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_VARIABLE_CABINET_TRADE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_TED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_SPREAD));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_FIXED_CABINET_TRADE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_CABINET_TRADE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligMode_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligMode_FINAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_FINAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityUpdateAction_DELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_DELETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityUpdateAction_ADD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_ADD));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityUpdateAction_MODIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_MODIFY));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetworkRequestType_STOP_SUBSCRIBING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOP_SUBSCRIBING));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetworkRequestType_SUBSCRIBE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SUBSCRIBE));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetworkRequestType_SNAPSHOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SNAPSHOT));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_EXECUTION_VENUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTION_VENUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CLIENT_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENT_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_DATA_ENTRY_ORIGINATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ORDER_ORIGINATION_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ORIGINATION_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_PLEDGEE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGEE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CONTRA_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_MULTILATERAL_TRADING_FACILITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_MULTILATERAL_TRADING_FACILITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CENTRAL_REGISTRATION_DEPOSITORY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_REPORT_ORIGINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORT_ORIGINATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_TRANSFER_TO_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRANSFER_TO_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_BROKERCLEARINGID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKERCLEARINGID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ASSET_MANAGER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ASSET_MANAGER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INTRODUCING_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_BROKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_LOCATE_LENDING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE_LENDING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CONTRA_CLEARING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_CLEARING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_GIVEUP_CLEARING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUP_CLEARING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_EXECUTING_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_EXECUTING_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_BROKER_OF_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKER_OF_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CORRESPONDANT_CLEARING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDANT_CLEARING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SETTLEMENT_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_LOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_THIRD_PARTY_ALLOCATION_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ORDER_ORIGINATION_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ORIGINATION_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_HOST_COMPETENT_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_HOST_COMPETENT_AUTHORITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ORDER_ENTRY_OPERATOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ENTRY_OPERATOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SPONSORING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INTRODUCING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CLEARING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CONTRA_POSITION_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_POSITION_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ENTERING_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_LOCATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_FORIEGN_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_FORIEGN_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ACCEPTABLE_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CUSTOMER_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMER_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_POSITION_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITION_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_LIQUIDITY_PROVIDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITY_PROVIDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_AGENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ENTERING_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_FOREIGN_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_FOREIGN_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CLEARING_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_HOME_COMPETENT_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_HOME_COMPETENT_AUTHORITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INTERESTED_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTED_PARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SESSION_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SESSION_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_REPORTING_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INVESTMENT_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTMENT_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_TRADER_MNEMONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRADER_MNEMONIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INTERNAL_CARRY_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERNAL_CARRY_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CONTRA_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CORRESPONDENT_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_BROKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CLEARING_ORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SUB_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUB_CUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_BUYER_SELLER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYER_SELLER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_STEP_OUT_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_STEP_OUT_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_MARKET_DATA_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_DATA_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CLAIMING_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLAIMING_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SECONDARY_ACCOUNT_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SECONDARY_ACCOUNT_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ALLOCATION_ENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCATION_ENTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_EXECUTING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_LOCATION_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATION_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_DESK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_DESK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_EXECUTING_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_BENEFICIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BENEFICIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_FUND_MANAGER_CLIENT_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_FUND_MANAGER_CLIENT_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CONTRA_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_UNACCEPTABLE_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_UNDERLYING_CONTRA_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNDERLYING_CONTRA_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_QUOTE_ORIGINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_QUOTE_ORIGINATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_REGULATED_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATED_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_ENTERING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SENDER_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SENDER_LOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_SYSTEMATIC_INTERNALISER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SYSTEMATIC_INTERNALISER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_CONTRA_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_REGULATORY_BODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORY_BODY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_PLEDGOR_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGOR_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AssignmentMethod_PRO_RATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRO_RATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_AssignmentMethod_RANDOM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_RANDOM));
  return _val;
}


SWIGINTERN VALUE
_wrap_AssignmentMethod_PRORATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRORATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_TZTIMEONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMEONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_MONTHYEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTHYEAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_QTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_BOOLEAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_BOOLEAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_MULTIPLECHARVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLECHARVALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_CHAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CHAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_NUMINGROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_NUMINGROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_TAGNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TAGNUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_COUNTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_COUNTRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_TENOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TENOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_LOCALMKTTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTTIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_INT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_INT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_LOCALMKTDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTDATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_LANGUAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LANGUAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_LENGTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LENGTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_TZTIMESTAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMESTAMP));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_MULTIPLESTRINGVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLESTRINGVALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_UTCTIMESTAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMESTAMP));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_DATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_DATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CURRENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_STRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_STRING));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_AMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_AMT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_FLOAT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_FLOAT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_UTCDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_UTCTIMEONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMEONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_SEQNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_SEQNUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_UTCDATEONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATEONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrategyParameterType_PRICEOFFSET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICEOFFSET));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_PGP_DES_MD5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGP_DES_MD5));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_PKCS_DES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS_DES));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_PKCS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_PGP_DES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGP_DES));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_DES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DES));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_NONE_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_EncryptMethod_PEM_DES_MD5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PEM_DES_MD5));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_ACCRUED_COUPON_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_ACCRUED_COUPON_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_PREMIUM_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUM_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_TOTAL_BANKED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_BANKED_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_SETTLEMENT_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_SETTLEMENT_VALUE);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_CASH_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_CASH_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INITIAL_TRADE_COUPON_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_INCREMENTAL_ACCRUED_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_ACCRUED_COUPON);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_VALUE_ADJUSTED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_VALUE_ADJUSTED_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_COLLATERALIZED_MARK_TO_MARKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_CASH_RESIDUAL_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_CASH_RESIDUAL_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_COMPENSATION_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_COMPENSATION_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_TRADE_VARIATION_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TRADE_VARIATION_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_COUPON_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_COUPON_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_COLLATERALIZED_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ResetSeqNumFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResetSeqNumFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_INVALID_DESTINATION_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_DESTINATION_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_SUCCESSFUL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_SUCCESSFUL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_INVALID_PARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_PARTIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRespType_DECLINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_DECLINED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRespType_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRespType_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRespType_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnsolicitedIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnsolicitedIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_INVALID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_TOO_LATE_TO_ENTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_UNKNOWN_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryRejectReason_DUPLICATE_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPLICATE_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCapacity_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCapacity_RISKLESS_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESS_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCapacity_AGENT_FOR_OTHER_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENT_FOR_OTHER_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCapacity_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCapacity_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCapacity_INDIVIDUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_INDIVIDUAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteAckStatus_CANCELED_FOR_UNDERLYING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_UNDERLYING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteAckStatus_CANCELED_ALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_ALL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteAckStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteAckStatus_CANCELED_FOR_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteAckStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_CHANGE_PASSWORD_FOR_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGE_PASSWORD_FOR_USER));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_CHANGEPASSWORDFORUSER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGEPASSWORDFORUSER));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_LOGOFFUSER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGOFFUSER));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_LOG_OFF_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOG_OFF_USER));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_LOGONUSER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGONUSER));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserRequestType_LOG_ON_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOG_ON_USER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportTransType_REVERSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REVERSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportTransType_RELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_RELEASE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvSide_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvSide_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvSide_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_BUY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvSide_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_SELL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CoveredOrUncovered_COVERED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_COVERED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CoveredOrUncovered_UNCOVERED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_UNCOVERED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AcctIDSource_TFM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFM));
  return _val;
}


SWIGINTERN VALUE
_wrap_AcctIDSource_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_BIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_AcctIDSource_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AcctIDSource_OMGEO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEO));
  return _val;
}


SWIGINTERN VALUE
_wrap_AcctIDSource_DTCC_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCC_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AcctIDSource_SID_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SID_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestType_ALL_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALL_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_HALTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_HALTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_PRE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_UNKNOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_UNKNOWN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_PRE_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatus_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_CLOSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_LAST_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_LAST_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_PRIMARY_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PRIMARY_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_OPENING_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_OPENING_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_TRAILING_STOP_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_TRAILING_STOP_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_PEG_TO_LIMIT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PEG_TO_LIMIT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_MID_PRICE_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MID_PRICE_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_MARKET_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MARKET_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegPriceType_PEG_TO_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PEG_TO_VWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnRejReason_NO_AVAILABLE_STREAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_NO_AVAILABLE_STREAM));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnRejReason_UNKNOWN_CLIENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_CLIENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ValuationMethod_PREMIUM_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_PREMIUM_STYLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_ValuationMethod_CDS_IN_DELIVERY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_IN_DELIVERY);
  return _val;
}


SWIGINTERN VALUE
_wrap_ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON);
  return _val;
}


SWIGINTERN VALUE
_wrap_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerType_SPECIFIED_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_SPECIFIED_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerType_NEXT_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_NEXT_AUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerType_PRICE_MOVEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_PRICE_MOVEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerType_PARTIAL_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_PARTIAL_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceProtectionScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceProtectionScope_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceProtectionScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceProtectionScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_INVALID_PARTY_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_PARTY_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_PARTY_ONFORMATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_UNKNOWN_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWN_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_SUCCESSFUL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFUL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportRejectReason_INVALID_TRADE_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_TRADE_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListType_NEWSPAPER_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_NEWSPAPER_LIST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListType_TRADING_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_TRADING_LIST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListType_INDUSTRY_CLASSIFICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_INDUSTRY_CLASSIFICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListType_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_QUOTE_LOCKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_LOCKED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_INVALID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_TOO_LATE_TO_ENTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_TOO_LATE_TO_ENTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_INVALID_BID_ASK_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_BID_ASK_SPREAD));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_UNKNOWN_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_DUPLICATE_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPLICATE_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PossResend_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossResend_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_PossResend_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossResend_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_SHARES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_SHARES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_CURRENTFACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENTFACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_PAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_BONDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_ORIGINALFACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_ORIGINALFACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_CONTRACTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_CONTRACTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuantityType_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ImpliedMarketIndicator_NOT_IMPLIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_NOT_IMPLIED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ImpliedMarketIndicator_IMPLIED_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ImpliedMarketIndicator_IMPLIED_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_IN));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestType_AUTOMATIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTOMATIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestType_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MANUAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestResult_VALID_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALID_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_ISSUER_HOLDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUER_HOLDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_NON_ALGORITHMIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_ALGORITHMIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_NON_INDEX_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_INDEX_ARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_PROGRAM_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAM_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_ISSUE_PRICE_STABILIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUE_PRICE_STABILIZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_FOREIGN_ENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FOREIGN_ENTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_INDEX_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEX_ARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_ALGORITHMIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ALGORITHMIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_RISKLESS_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKLESS_ARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderRestrictions_COMPETING_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_COMPETING_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_IMMEDIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMEDIATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_FED_WIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FED_WIRE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_EUROCLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_EUROCLEAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_ACH_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACH_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHIC_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_FEDWIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FEDWIRE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_CHEQUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CHEQUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_DIRECT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_CREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CREST));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_CLEARSTREAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CLEARSTREAM));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_BPAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_BPAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_NSCC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_NSCC));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS));
  return _val;
}


SWIGINTERN VALUE
_wrap_DistribPaymentMethod_REINVEST_IN_FUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_REINVEST_IN_FUND));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderHandlingInstSource_NASD_OATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_NASD_OATS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AffirmStatus_AFFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_AFFIRMED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AffirmStatus_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrigCustOrderCapacity_ALL_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_ALL_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocMethod_GUARANTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocMethod_GUARANTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocMethod_AUTOMATIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocMethod_AUTOMATIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocMethod_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocMethod_MANUAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ALL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ALL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN);
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestinationIDSource_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestinationIDSource_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_BIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestinationIDSource_MIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_MIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestinationIDSource_ISO_COUNTRY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_ISO_COUNTRY_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListRequestType_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListRequestType_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListRequestType_ALL_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALL_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityListRequestType_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_TIME_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIME_WARNING));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_ADVERSE_TAX_EVENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_ADVERSE_TAX_EVENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_MARGIN_DEFICIENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_DEFICIENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_SCHEDULED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_SCHEDULED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_INITIAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_INITIAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_FORWARD_COLLATERAL_DEMAND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_EVENT_OF_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_EVENT_OF_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnReason_MARGIN_EXCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_EXCESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlPriceType_FINAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_FINAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlPriceType_THEORETICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_THEORETICAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DealingCapacity_RISKLESS_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_RISKLESS_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DealingCapacity_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DealingCapacity_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_AGENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_RateSourceType_SECONDARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSourceType_SECONDARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_RateSourceType_PRIMARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSourceType_PRIMARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AggregatedBook_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_AggregatedBook_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosQtyStatus_SUBMITTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_SUBMITTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosQtyStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosQtyStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradingSessionStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ListStatus_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListStatus);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Email_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Email);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ListExecute_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListExecute);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Confirmation_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Confirmation);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_NewOrderMultileg_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderMultileg);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDataIncrementalRefresh_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataIncrementalRefresh);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradeCaptureReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_RequestForPositionsAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RequestForPositionsAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_StreamAssignmentRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityListRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CollateralReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_PositionMaintenanceReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_PositionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PositionReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_StreamAssignmentReportACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReportACK);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_UserRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_UserRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_PositionMaintenanceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_NetworkCounterpartySystemStatusResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusResponse);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_NewOrderCross_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderCross);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AdjustedPositionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AdjustedPositionReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Logon_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Logon);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_IOI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_IOI);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ListStrikePrice_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListStrikePrice);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_BidRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_BidRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradingSessionStatus_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatus);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_RegistrationInstructionsResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructionsResponse);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Advertisement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Advertisement);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MassQuote_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MassQuote);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Logout_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Logout);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AllocationReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityDefinitionUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionUpdateReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ListStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_BusinessMessageReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_BusinessMessageReject);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ConfirmationAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ConfirmationAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_XMLnonFIX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_XMLnonFIX);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TestRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TestRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityList);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ListCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListCancelRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_News_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_News);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradingSessionListUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListUpdateReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Heartbeat_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Heartbeat);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteAcknowledgement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteAcknowledgement);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AllocationReportAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationReportAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ConfirmationRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ConfirmationRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderMassActionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CollateralInquiry_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiry);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityTypeRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityTypeRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_NewOrderList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderList);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ExecutionAcknowledgement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ExecutionAcknowledgement);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradingSessionListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityTypes_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityTypes);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDefinition_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDefinition);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SequenceReset_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SequenceReset);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CollateralResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralResponse);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MassQuoteAcknowledgement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MassQuoteAcknowledgement);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteResponse);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteCancel_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteCancel);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ContraryIntentionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ContraryIntentionReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CrossOrderCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_NewOrderSingle_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderSingle);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_DerivativeSecurityListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CollateralRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_UserNotification_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_UserNotification);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_UserResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_UserResponse);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_DontKnowTrade_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DontKnowTrade);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradeCaptureReportAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ApplicationMessageRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MultilegOrderCancelReplace_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplace);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderCancelReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReject);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ExecutionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ExecutionReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteStatusReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ResendRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ResendRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Quote_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Quote);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SettlementInstructionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructionRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityListUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityListUpdateReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AllocationInstructionAlert_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlert);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradeCaptureReportRequestAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequestAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AllocationInstruction_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationInstruction);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Allocation_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Allocation);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_RegistrationInstructions_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructions);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityDefinition_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinition);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityDefinitionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityStatus_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityStatus);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ApplicationMessageReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_DerivativeSecurityList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityList);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_NetworkCounterpartySystemStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDefinitionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_Reject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Reject);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_DerivativeSecurityListUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListUpdateReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteRequestReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteRequestReject);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderMassStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_ApplicationMessageRequestAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequestAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SecurityStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDefinitionUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionUpdateReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CrossOrderCancelReplaceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelReplaceRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderMassCancelReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AssignmentReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AssignmentReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_BidResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_BidResponse);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_RequestForPositions_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RequestForPositions);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SettlementObligationReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SettlementObligationReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderMassCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradingSessionList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionList);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderStatusRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CollateralAssignment_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralAssignment);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_StreamAssignmentReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReport);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderMassActionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AllocationAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_QuoteRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_CollateralInquiryAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiryAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDataSnapshotFullRefresh_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataSnapshotFullRefresh);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_SettlementInstructions_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructions);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderCancelReplaceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReplaceRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_TradeCaptureReportRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_RFQRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RFQRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_OrderCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderCancelRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MultilegOrderCancelReplaceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplaceRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_AllocationInstructionAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAck);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDataRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequest);
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgType_MarketDataRequestReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequestReject);
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegReportingType_SINGLE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegReportingType_MULTI_LEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_MULTI_LEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_EXCHANGE_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_EXCHANGE_SYMBOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_RIC_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_RIC_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_ISO_CURRENCY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_ISO_CURRENCY_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_ISIN_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_ISIN_NUMBER);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_SEDOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_SEDOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_ISO_COUNTRY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_ISO_COUNTRY_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_QUIK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_QUIK);
  return _val;
}


SWIGINTERN VALUE
_wrap_IDSource_CUSIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_CUSIP);
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_PENDING_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_PENDING_CANCEL_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_PENDING_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_STOPPED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_FILLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_FILLED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_PENDING_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_CANCELED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CANCELED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_ACCEPTED_FOR_BIDDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_ACCEPTED_FOR_BIDDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_SUSPENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_SUSPENDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_PARTIALLY_FILLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIALLY_FILLED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_REPLACED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REPLACED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdStatus_DONE_FOR_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_DONE_FOR_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_CustomerOrFirm_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_CustomerOrFirm_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdjustmentType_DELTA_MINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_MINUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdjustmentType_DELTA_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_PLUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdjustmentType_FINAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_FINAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION));
  return _val;
}


SWIGINTERN VALUE
_wrap_AsOfIndicator_TRUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_TRUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AsOfIndicator_FALSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_FALSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_CANCEL_FOR_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_VenueType_PIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::VenueType_PIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_VenueType_EX_PIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::VenueType_EX_PIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_VenueType_ELECTRONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::VenueType_ELECTRONIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionType_CANCEL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionType_CANCEL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionType_RELEASE_ORDERS_FROM_SUSPENSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionType_SUSPEND_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionType_SUSPEND_ORDERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintResult_SUCCESSFUL_COMPLETION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFUL_COMPLETION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintResult_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIShares_MEDIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIShares_MEDIUM);
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIShares_LARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIShares_LARGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIShares_SMALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIShares_SMALL);
  return _val;
}


SWIGINTERN VALUE
_wrap_PegOffsetType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegOffsetType_PRICE_TIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE_TIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegOffsetType_TICKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_TICKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegOffsetType_BASIS_POINTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASIS_POINTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResponseTransportType_INBAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResponseTransportType_OUT_OF_BAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUT_OF_BAND));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesStatusRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_EXECUTION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTION_TIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_TIME_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_IN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_SUBMISSION_TO_CLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_SUBMISSION_TO_CLEARING));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_DESK_RECEIPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_DESK_RECEIPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_BROKER_RECEIPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_RECEIPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_BROKER_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRegTimestampType_TIME_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX50SP1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP1);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX27_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX27);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX50SP2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP2);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX50_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX50);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX40_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX40);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX41_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX41);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX30_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX30);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX42_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX42);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX43_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX43);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplVerID_FIX44_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX44);
  return _val;
}


SWIGINTERN VALUE
_wrap_HandlInst_MANUAL_ORDER_BEST_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HandlInst_MANUAL_ORDER_BEST_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_POST_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_POST_TRADING);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_INTRADAY_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_INTRADAY_AUCTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_PRE_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_PRE_TRADING);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_QUIESCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_QUIESCENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_3);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_OPENING_OR_OPENING_AUCTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SWAP_VALUE_FACTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SWAP_VALUE_FACTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_COMPOSITE_UNDERLYING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_COMPOSITE_UNDERLYING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SESSION_HIGH_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SESSION_HIGH_BID));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_OPEN_INTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPEN_INTEREST));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_PRIOR_SETTLE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_PRIOR_SETTLE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_TRADING_SESSION_VWAP_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_VWAP_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_TRADING_SESSION_LOW_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_LOW_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SETTLE_HIGH_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLE_HIGH_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_FIXING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_FIXING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_CASH_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CASH_RATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_OPENING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SIMULATED_SELL_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SIMULATED_SELL_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_EMPTY_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EMPTY_BOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_AUCTION_CLEARING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_AUCTION_CLEARING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_BID));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_RECOVERY_RATE_FOR_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE_FOR_SHORT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SIMULATED_BUY_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SIMULATED_BUY_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_EARLY_PRICES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EARLY_PRICES));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_TRADING_SESSION_HIGH_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_HIGH_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_INDEX_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEX_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_RECOVERY_RATE_FOR_LONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE_FOR_LONG));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_MID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MID_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_RECOVERY_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_MARGIN_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARGIN_RATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SETTLE_LOW_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLE_LOW_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SESSION_LOW_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SESSION_LOW_OFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_TRADE_VOLUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE_VOLUME));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_SETTLEMENT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDEntryType_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegMoveType_FLOATING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FLOATING));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegMoveType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FIXED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID));
  return _val;
}


SWIGINTERN VALUE
_wrap_AvgPxIndicator_NO_AVERAGE_PRICING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_NO_AVERAGE_PRICING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID));
  return _val;
}


SWIGINTERN VALUE
_wrap_AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_NO_WAIVER_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_WAIVER_AGREEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_NO_M_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_M));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_NO_N_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_N));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_NO_INSTITUTIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_INSTITUTIONAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_NO_O_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_O));
  return _val;
}


SWIGINTERN VALUE
_wrap_CancellationRights_NO_EXECUTION_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_EXECUTION_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_CREATION_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_BID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BID_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_SINGLE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecPriceType_OFFER_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_PHONE_FOR_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocSettlInstType_SSI_DB_IDS_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_SSI_DB_IDS_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocSettlInstType_FULL_DETAILS_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_FULL_DETAILS_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatsType_AVERAGE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_AVERAGE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatsType_HIGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_HIGH));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatsType_EXCHANGE_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_EXCHANGE_LAST));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatsType_TURNOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_TURNOVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesMode_SIMULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMode_SIMULATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesMode_PRODUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMode_PRODUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesMode_TESTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMode_TESTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTITUTIONS_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstSource_BROKERS_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKERS_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstSource_INVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpType_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpType_FINAL_WILL_BE_EXERCISED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_FINAL_WILL_BE_EXERCISED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpType_NON_AUTO_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_NON_AUTO_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpType_CONTRARY_INTENTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_CONTRARY_INTENTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpType_AUTO_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_AUTO_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstTransType_RESTATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_RESTATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_INVALID_DESTINATION_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_DESTINATION_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_SUCCESSFUL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_SUCCESSFUL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_INVALID_PARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_PARTIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_NOT_AUTHORIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_NOT_AUTHORIZED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TestMessageIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_TestMessageIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocCancReplaceReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_DUPLICATE_CLORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CLORDID));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_DUPLICATE_CLORDID_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CLORDID_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_UNKNOWN_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_TOO_LATE_TO_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_TOO_LATE_TO_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_INVALID_PRICE_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_INVALID_PRICE_INCREMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_ORIGORDMODTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_BROKER_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RespondentType_SPECIFIED_MARKET_PARTICIPANTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RespondentType_ALL_MARKET_MAKERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RespondentType_ALL_MARKET_MAKERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RespondentType_ALL_MARKET_PARTICIPANTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RespondentType_ALL_MARKET_PARTICIPANTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RespondentType_PRIMARY_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RespondentType_PRIMARY_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_NO_MATCHING_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_NO_MATCHING_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_PRICE_EXCEEDS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_PRICE_EXCEEDS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_QUANTITY_EXCEEDS_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_QUANTITY_EXCEEDS_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_WRONG_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONG_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DKReason_CALCULATION_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATION_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PositionEffect_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PositionEffect_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_PositionEffect_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_PositionEffect_FIFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_FIFO));
  return _val;
}


SWIGINTERN VALUE
_wrap_PositionEffect_ROLLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_ROLLED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerAction_ACTIVATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerAction_ACTIVATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerAction_MODIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerAction_MODIFY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerAction_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerAction_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDE_FROM_ALL_NETTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_AUTOMATIC_POSTING_MODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATIC_POSTING_MODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_MULTILATERAL_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERAL_NETTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATIC_GIVE_UP_MODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_CUSTOMER_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMER_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_EX_CLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EX_CLEARING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_BILATERAL_NETTING_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_BILATERAL_NETTING_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_PROCESS_NORMALLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESS_NORMALLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_SPECIAL_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIAL_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_MANUAL_MODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUAL_MODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ClearingInstruction_SELF_CLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELF_CLEARING));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_SESSION_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSION_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_EXPECTED_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTED_ENTRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_DAILY_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILY_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionMoveType_FLOATING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FLOATING));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionMoveType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FIXED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateType_INCREMENTAL_REFRESH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL_REFRESH));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateType_FULL_REFRESH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL_REFRESH));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickDirection_MINUS_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickDirection_ZERO_PLUS_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZERO_PLUS_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickDirection_ZERO_MINUS_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZERO_MINUS_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickDirection_PLUS_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_MARK_TO_MARKET_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_PREVIOUS_CLOSE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_AT_ISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_AT_ISSUE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_NEXT_REFUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_REFUND);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_AFTER_TAX_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_AFTER_TAX_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_GVNT_EQUIVALENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_GVNT_EQUIVALENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_YEAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_NEXT_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_CHANGE_SINCE_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_PROCEEDS_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CURRENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_COMPOUND_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_AVG_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVG_MATURITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_TENDER_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_ANNUAL_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_WORST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_NEXT_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_BOOK_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_TRUE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_TAX_EQUIVALENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_TRUE_GROSS_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_LONGEST_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_INVERSE_FLOATER_BOND_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_MONTH);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_SHORTEST_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_OPEN_AVERAGE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_AVERAGE_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_SIMPLE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_SEMI_ANNUAL_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_MOST_RECENT_CLOSING_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_GOVERNMENT_EQUIVALENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_GOVERNMENT_EQUIVALENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_CLOSING_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_VALUE_OF_1_32_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_VALUE_OF_1_32);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS);
  return _val;
}


SWIGINTERN VALUE
_wrap_YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_PegScope_NATIONAL_XXCLUDING_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL_XXCLUDING_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegScope_NATIONAL_EXCLUDING_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL_EXCLUDING_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlDeliveryType_TRI_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_TRI_PARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlDeliveryType_HOLD_IN_CUSTODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_HOLD_IN_CUSTODY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlDeliveryType_FREE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlDeliveryType_VERSUS_PAYMENT_DELIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS_PAYMENT_DELIVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlDeliveryType_FREE_DELIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE_DELIVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlDeliveryType_VERSUS_PAYMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS_PAYMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionLimitType_STRICT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionLimitType_OR_BETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_BETTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionLimitType_OR_WORSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExerciseMethod_AUTOMATIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_AUTOMATIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExerciseMethod_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_MANUAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_WorkingIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_WorkingIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideMultiLegReportingType_MULTILEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideMultiLegReportingType_SINGLE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideMultiLegReportingType_MULTI_LEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTI_LEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmRejReason_MISMATCHED_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHED_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidRequestTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidRequestTransType_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidRequestTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollApplType_GENERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollApplType_GENERAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollApplType_SPECIFIC_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollApplType_SPECIFIC_DEPOSIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmType_CONFIRMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmType_CONFIRMATION_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmType_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmType_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDQuoteType_INDICATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDQuoteType_RESTRICTED_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_RESTRICTED_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDQuoteType_INDICATIVE_AND_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE_AND_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDQuoteType_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDQuoteType_COUNTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_COUNTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QtyType_CONTRACTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QtyType_CONTRACTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QtyType_UNITS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_END_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_END_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_COVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_HIT_LIFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HIT_LIFT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_DONE_AWAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONE_AWAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_TIMED_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIMED_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_PASS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_PASS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRespType_COUNTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COUNTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOINaturalFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOINaturalFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligSource_INSTRUCTIONS_OF_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INSTRUCTIONS_OF_BROKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligSource_INVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INVESTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_ON_HOURS_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ON_HOURS_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_INTERIM_PROTECTED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_INTERIM_PROTECTED_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_K_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_K));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_LC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LC));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_WN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_CONVERTED_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CONVERTED_SWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_B_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_B));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_M_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_M));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_RT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ONSET_DUE_TO_AN_ALLOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_CMTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CMTA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_DIFFERENTIAL_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_DIFFERENTIAL_SPREAD));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_TRANSACTION_FROM_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRANSACTION_FROM_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRANSACTION_FROM_ASSIGNMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_N_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_N));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_NR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_SW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_SW));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_OTC_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OTC_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ADVISORY_FOR_CONTRA_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_P_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_P));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_CROSSED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CROSSED_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_PA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_R_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_R));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_RO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RO));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_WT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_OFF_HOURS_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OFF_HOURS_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_REJECT_FOR_SUBMITTING_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ONSET_DUT_TO_AN_ALLOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_AI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_AI));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_PC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PC));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_PN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_LARGE_IN_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LARGE_IN_SCALE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_NM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NM));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_T_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_T));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdSubType_ACATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ACATS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecTransType_CORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CORRECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecTransType_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_DayBookingInst_ACCUMULATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_ACCUMULATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING));
  return _val;
}


SWIGINTERN VALUE
_wrap_FlowScheduleType_NERC_EASTERN_OFF_PEAK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_EASTERN_OFF_PEAK));
  return _val;
}


SWIGINTERN VALUE
_wrap_FlowScheduleType_NERC_WESTERN_PEAK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_WESTERN_PEAK));
  return _val;
}


SWIGINTERN VALUE
_wrap_FlowScheduleType_NERC_EASTERN_PEAK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_EASTERN_PEAK));
  return _val;
}


SWIGINTERN VALUE
_wrap_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_FlowScheduleType_NERC_WESTERN_OFF_PEAK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_WESTERN_OFF_PEAK));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDOriginType_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDOriginType_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDOriginType_OFF_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDOriginType_OFF_BOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDOriginType_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDOriginType_BOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED_WITH_WARNINGS));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollInquiryStatus_COMPLETED_WITH_WARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED_WITH_WARNINGS));
  return _val;
}


SWIGINTERN VALUE
_wrap_CPProgram_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CPProgram_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_CPProgram_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_BACKOUT_MESSAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_BACKOUT_MESSAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_DELTA_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_DELTA_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_SETTLEMENT_ACTIVITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_SETTLEMENT_ACTIVITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_EXERCISES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_EXERCISES));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqType_ASSIGNMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_ASSIGNMENTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ALL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ALL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SubscriptionRequestType_SNAPSHOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsCategory_MARKETPLACE_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_MARKETPLACE_NEWS));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsCategory_TECHNICAL_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_TECHNICAL_NEWS));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsCategory_COMPANY_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_COMPANY_NEWS));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsCategory_OTHER_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_OTHER_NEWS));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsCategory_FINANCIAL_MARKET_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_FINANCIAL_MARKET_NEWS));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQty_MEDIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_MEDIUM);
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQty_LARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_LARGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQty_SMALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_SMALL);
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQty_UNDISCLOSED_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_UNDISCLOSED_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplResponseError_APPLICATION_DOES_NOT_EXIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_APPLICATION_DOES_NOT_EXIST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_LIQUIDITY_ROUTED_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastLiquidityInd_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_AUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastLiquidityInd_ADDED_LIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDED_LIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastLiquidityInd_REMOVED_LIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVED_LIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceDeterminationMethod_FIXED_STRIKE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_FIXED_STRIKE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TargetStrategy_PARTICIPATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_PARTICIPATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TargetStrategy_MININIZE_MARKET_IMPACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_MININIZE_MARKET_IMPACT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TargetStrategy_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_VWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_DueToRelated_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DueToRelated_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_DueToRelated_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DueToRelated_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingCashType_DIFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnderlyingCashType_DIFF);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingCashType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnderlyingCashType_FIXED);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderCapacity_ALL_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_ALL_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnershipType_JOINT_TRUSTEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_TRUSTEES));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnershipType_JOINT_INVESTORS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_INVESTORS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnershipType_TENANTS_IN_COMMON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OwnershipType_TENANTS_IN_COMMON));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_US_DOLLARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_DOLLARS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_TONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_TONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_TROY_OUNCES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_TROY_OUNCES);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_MEGAWATT_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_HOURS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_ONE_MILLION_BTU_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_ONE_MILLION_BTU);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_BILLION_CUBIC_FEET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_BILLION_CUBIC_FEET);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_MILLION_BARRELS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLION_BARRELS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_GALLONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_GALLONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_BARRELS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_BARRELS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_POUNDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_POUNDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_METRIC_TONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_METRIC_TONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_ALLOWANCES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_ALLOWANCES);
  return _val;
}


SWIGINTERN VALUE
_wrap_UnitOfMeasure_BUSHELS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_BUSHELS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_WHEN_AND_IF_ISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_AND_IF_ISSUED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_T_PLUS_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_1));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_FUTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_FUTURE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_SELLERS_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_SELLERS_OPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_T_PLUS_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_2));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_T_PLUS_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_T_PLUS_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_REGULAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_T_PLUS_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_5));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_WHEN_ISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_ISSUED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_NEXT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_NEXT_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlmntTyp_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_CASH));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DO_NOT_PUBLISH_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradePublishIndicator_DEFERRED_PUBLICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DEFERRED_PUBLICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradePublishIndicator_PUBLISH_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_PUBLISH_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplResponseType_MESSAGES_NOT_AVAILABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_MESSAGES_NOT_AVAILABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplResponseType_APPLICATION_DOES_NOT_EXIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_APPLICATION_DOES_NOT_EXIST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_StandInstDbType_DTC_SID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_DTC_SID));
  return _val;
}


SWIGINTERN VALUE
_wrap_StandInstDbType_ACCOUNTNET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ACCOUNTNET));
  return _val;
}


SWIGINTERN VALUE
_wrap_StandInstDbType_A_GLOBAL_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_A_GLOBAL_CUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_StandInstDbType_THOMSON_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_THOMSON_ALERT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StandInstDbType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_CROSS_MARKET_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CROSS_MARKET_WARNING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_LOCKED_MARKET_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_LOCKED_MARKET_WARNING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_REMOVED_FROM_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REMOVED_FROM_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteEntryStatus_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACTIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceType_BEST_MID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_MID));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceType_BEST_BID_OR_LAST_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID_OR_LAST_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceType_BEST_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER_OR_LAST_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceType_BEST_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceType_LAST_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_LAST_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstReqRejCode_UNKNOWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstReqRejCode_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Urgency_FLASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Urgency_FLASH));
  return _val;
}


SWIGINTERN VALUE
_wrap_Urgency_NORMAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Urgency_NORMAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Urgency_BACKGROUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Urgency_BACKGROUND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnTransType_REVERSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REVERSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnTransType_RELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_RELEASE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_FED_WIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FED_WIRE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_EUROCLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_EUROCLEAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_ACH_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_TELEGRAPHIC_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHIC_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_FEDWIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FEDWIRE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_DIRECT_DEBIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_DEBIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_CREDIT_CARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDIT_CARD));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_CHEQUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHEQUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_DIRECT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_CREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREST));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_CLEARSTREAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CLEARSTREAM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_BPAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_BPAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_NSCC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_NSCC));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_DEBIT_CARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBIT_CARD));
  return _val;
}


SWIGINTERN VALUE
_wrap_PaymentMethod_ACH_DEBIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_DEBIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceTypeScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceTypeScope_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceTypeScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerPriceTypeScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegLimitType_STRICT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegLimitType_OR_BETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_BETTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegLimitType_OR_WORSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_BORROW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BORROW));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_BUY_MINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BUY_MINUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_SUBSCRIBE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SUBSCRIBE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_CROSS_SHORT_EXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT_EXEMPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_UNDISCLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_UNDISCLOSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_SELL_SHORT_EXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT_EXEMPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BUY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_CROSS_SHORT_EXXMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT_EXXMPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_LEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_LEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_SELL_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_OPPOSITE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_OPPOSITE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_CROSS_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_SELL_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL_PLUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_REDEEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_REDEEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_Side_AS_DEFINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_AS_DEFINED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_EXIT_CHARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_DILUTION_LEVY_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_DILUTION_LEVY_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_DISCOUNT_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_COMMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_INITIAL_CHARGE_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_DILUTION_LEVY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_COMMISSION_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_NET_SETTLEMENT_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_NET_SETTLEMENT_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_EXIT_CHARGE_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_INITIAL_CHARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_DISCOUNT_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_EXIT_CHARGE_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_COMMISSION_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_PROJECTED_FUND_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_PROJECTED_FUND_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContAmtType_INITIAL_CHARGE_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_IMPLIED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_IMPLIED_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_STREAMING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_STREAMING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_QUOTE_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_CROSS_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_CROSS_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_MULTILEG_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_MULTILEG_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_PRIVATELY_NEGOTIATED_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderCategory_LINKED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_LINKED_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_REPLACE);
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_NEW);
  return _val;
}


SWIGINTERN VALUE
_wrap_AdvTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_CANCEL);
  return _val;
}


SWIGINTERN VALUE
_wrap_PublishTrdIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_PublishTrdIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_REJECT_SECURITY_PROPOSAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_REJECT_SECURITY_PROPOSAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_PASSWORD_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_PASSWORD_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_SESSION_LOGOUT_COMPLETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_LOGOUT_COMPLETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_INVALID_USERNAME_OR_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_INVALID_USERNAME_OR_PASSWORD));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_SESSION_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_ACTIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_SESSION_PASSWORD_CHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_PASSWORD_CHANGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_ACCOUNT_LOCKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_ACCOUNT_LOCKED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_HOUSE_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSE_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_FLOOR_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOOR_TRADER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_JOINT_BACKOFFICE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JOINT_BACKOFFICE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_REVERSAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REVERSAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED_WITHOUT_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationQtyType_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_FINAL_WILL_BE_EXERCISED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationQtyType_NON_AUTO_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_NON_AUTO_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationQtyType_CONTRARY_INTENTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_CONTRARY_INTENTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExpirationQtyType_AUTO_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_AUTO_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocHandlInst_FORWARD_AND_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD_AND_MATCH));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocHandlInst_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocHandlInst_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_MATCH));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeRequestStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST));
  return _val;
}


SWIGINTERN VALUE
_wrap_PreallocMethod_PRO_RATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRO_RATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_PreallocMethod_DO_NOT_PRO_RATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRO_RATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_457_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_457));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_MAXI_ISA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXI_ISA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_CURRENT_YEAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYEE_9_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_9));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_403_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_403));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_KEOGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGH));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_401K_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401K));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_SELF_DIRECTED_IRA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_SELF_DIRECTED_IRA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_ROTH_IRA_24_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_IRA_24));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_CURRENT_YEAR_PAYMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_CURRENT_YEAR_PAYMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_MINI_INSURANCE_ISA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_INSURANCE_ISA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EDUCATION_IRA_28_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATION_IRA_28));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_ROTH_IRA_25_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_IRA_25));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYEE_10_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_10));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EDUCATION_IRA_29_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATION_IRA_29));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_PRIOR_YEAR_PAYMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PRIOR_YEAR_PAYMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYER_11_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_11));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_ASSET_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSET_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYER_12_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_12));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_ROTH_CONVERSION_IRA_26_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_CONVERSION_IRA_26));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_MINI_CASH_ISA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_CASH_ISA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_ROTH_CONVERSION_IRA_27_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_CONVERSION_IRA_27));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_NONE_NOT_APPLICABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONE_NOT_APPLICABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_TESSA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NON_FUND_QUALIFIED_PLAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_CURRENT_YEAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_EMPLOYER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_PROFIT_SHARING_PLAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PROFIT_SHARING_PLAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_401_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401));
  return _val;
}


SWIGINTERN VALUE
_wrap_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NON_FUND_PROTOTYPE_IRA));
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_EUC_JP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_EUC_JP);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_SHIFT_JIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_SHIFT_JIS);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_UTF_8_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_UTF_8);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_ISO_2022_JP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_ISO_2022_JP);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_EUC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_EUC);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_JIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_JIS);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_FOR_USING_SJIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_FOR_USING_SJIS);
  return _val;
}


SWIGINTERN VALUE
_wrap_MessageEncoding_UNICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_UNICODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_GOOD_TILL_CROSSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_CROSSING));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_FILL_OR_KILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_FILL_OR_KILL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_GOOD_TILL_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_GOOD_TILL_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_AT_CROSSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_CROSSING));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_IMMEDIATE_OR_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_IMMEDIATE_OR_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_GOOD_THROUGH_CROSSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_THROUGH_CROSSING));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_AT_THE_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_THE_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeInForce_AT_THE_OPENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_THE_OPENING));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_THROUGH_THE_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_THROUGH_THE_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_INDIDCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDIDCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_AT_THE_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_AT_THE_MIDPOINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_MIDPOINT));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_CROSSING_OPPORTUNITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSING_OPPORTUNITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_CURRENT_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CURRENT_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_IN_TOUCH_WITH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_IN_TOUCH_WITH));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ALL_OR_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_TAKING_A_POSITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_TAKING_A_POSITION));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_AT_THE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_PORTFOLIO_SHOW_N_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOW_N));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_MARKET_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MARKET_ON_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_VERSUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VERSUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_PORTFOLIO_SHOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOWN));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_READY_TO_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_READY_TO_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_PRE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PRE_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_INDICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_MORE_BEHIND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MORE_BEHIND));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIQualifier_AT_THE_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return _val;
}


SWIGINTERN VALUE
_wrap_StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_CONVERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_CONVERSION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_CONSUMPTION_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION_TAX);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_LOCAL_COMMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_LOCAL_COMMISSION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_TAX);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_MARKUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_MARKUP);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_SECURITY_LENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_SECURITY_LENDING);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_PER_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_PER_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_REGULATORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_REGULATORY);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_STAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_STAMP);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_TRANSFER_FEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSFER_FEE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_AGENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_OTHER);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_EXCHANGE_FEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHANGE_FEES);
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeType_LEVY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_LEVY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_CLEARING_HOUSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARING_HOUSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_EXCHANGE_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHANGE_SYMBOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_SICOVAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_SICOVAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_ISDA_FPML_PRODUCT_URL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_URL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_RIC_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_ISO_CURRENCY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_CURRENCY_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_COMMON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_COMMON);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_VALOREN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_VALOREN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_BELGIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_BELGIAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_ISIN_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN_NUMBER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_SEDOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_SEDOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_ISO_COUNTRY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_COUNTRY_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_LETTER_OF_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_LETTER_OF_CREDIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_BLOOMBERG_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_BLOOMBERG_SYMBOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_WERTPAPIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_WERTPAPIER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_DUTCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_DUTCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_QUIK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_QUIK);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityIDSource_CUSIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CUSIP);
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsRefType_OTHER_LANGUAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsRefType_OTHER_LANGUAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsRefType_COMPLIMENTARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsRefType_COMPLIMENTARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_NewsRefType_REPLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsRefType_REPLACEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerOrderType_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TriggerOrderType_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_AON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_AON));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_ONE_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_ONE_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_SAME_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_SAME_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_IOC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_IOC));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettleFlag_SESSION_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_SESSION_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettleFlag_DAILY_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DAILY_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettleFlag_EXPECTED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_EXPECTED_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDBookType_PRICE_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDBookType_PRICE_DEPTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDBookType_ORDER_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDBookType_ORDER_DEPTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDBookType_TOP_OF_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDBookType_TOP_OF_BOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_MORNING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_VWAP_THROUGH_A_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_OTHERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OTHERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_CURRENT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRENT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_SQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_SQ));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_STRIKE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_STRIKE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI));
  return _val;
}


SWIGINTERN VALUE
_wrap_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_ROLLING_BARRIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_ROLLING_BARRIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_UNDERLYING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_UNDERLYING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_KNOCK_OUT_UP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_OUT_UP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_KNOCK_IN_UP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_IN_UP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_KOCK_IN_DOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KOCK_IN_DOWN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_TRIGGER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_TRIGGER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_RESET_BARRIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_RESET_BARRIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_CAPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_CAPPED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventType_KNOCK_OUT_DOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_OUT_DOWN));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionResponse_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassActionResponse_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_LIST_SECURITY_TYPES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_REQUEST_LIST_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_LIST_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_ALL_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_ALL_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_EXCHANGE_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_EXCHANGE_CLOSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_UNKNOWN_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNKNOWN_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_DUPLICATE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_DUPLICATE_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_TOO_LATE_TO_ENTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_TOO_LATE_TO_ENTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListRejectReason_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_BROKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_PROPRIETARY);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_ARBITRAGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_TRADING);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_DERIVATIVES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_DERIVATIVES);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_SALES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_SALES);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_INSTITUTIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_INSTITUTIONAL);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_INTERNATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_INTERNATIONAL);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_AGENCY);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_PREFERRED_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_PREFERRED_TRADING);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_OTHER);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskType_PROGRAM_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_PROGRAM_TRADING);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_WHEN_AND_IF_ISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_WHEN_AND_IF_ISSUED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_FUTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_FUTURE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_BROKEN_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_BROKEN_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_SELLERS_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_SELLERS_OPTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_T_PLUS_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_2);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_T_PLUS_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_3);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_T_PLUS_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_4);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_REGULAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_FX_SPOT_NEXT_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_FX_SPOT_NEXT_SETTLEMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_T_PLUS_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_5);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_NEXT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_NEXT_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlType_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_CASH);
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenClose_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenClose_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OpenClose_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenClose_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContractMultiplierUnit_SHARES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_SHARES));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContractMultiplierUnit_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_HOURS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ContractMultiplierUnit_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_DAYS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_FUTURES_LARGE_ORDER_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_FUTURES_LARGE_ORDER_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_BLOCK_TRADE_38_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE_38));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_DELTA_NEUTRAL_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_DELTA_NEUTRAL_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_LATE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_CASH_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_CASH_SETTLEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_CUM_BONUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_BONUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_BLOCK_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_ALL_OR_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_OPTION_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_FINANCING_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_FINANCING_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_TRADING_AT_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_TRADING_AT_SETTLEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_EX_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_EX_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_COUPON));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_CUM_RIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_RIGHTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_EX_BONUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_BONUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_REGULAR_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULAR_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_GRANTED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_GRANTED_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_BASIS_FACILITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_BASIS_FACILITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_BLOCK_TRADE_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE_1));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_ERROR_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_ERROR_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_NAME_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_NAME_CHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_LATE_BUNCHED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_BUNCHED_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EFP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EFP));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_NON_STANDARD_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_NON_STANDARD_SETTLEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_FOR_RISK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_FOR_RISK));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_FOR_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_FOR_SWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_OF_FUTURES_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_FUTURES_FOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_OPTION_INTERIM_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_INTERIM_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_PRIVATELY_NEGOTIATED_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIVATELY_NEGOTIATED_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_CUM_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_GUARANTEED_DELIVERY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_GUARANTEED_DELIVERY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_PROROGATION_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_SELL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_PRIOR_REFERENCE_PRICE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIOR_REFERENCE_PRICE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_PORTFOLIO_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_WORKED_PRINCIPAL_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_WORKED_PRINCIPAL_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_PORTFOLIO_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_WEIGHTED_AVERAGE_PRICE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_CUM_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_COUPON));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_T_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_T_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_BLOCK_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_OTC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_OTC));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_AFTER_HOURS_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_AFTER_HOURS_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_DERIVATIVE_RELATED_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_DERIVATIVE_RELATED_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_REPURCHASE_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_REPURCHASE_AGREEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_SPECIAL_EX_RIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_RIGHTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_PROROGATION_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_BUY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_OPTION_CABINET_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_CABINET_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdType_BUNCHED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHED_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RestructuringType_MODIFIED_MOD_RESTRUCTURING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_MOD_RESTRUCTURING);
  return _val;
}


SWIGINTERN VALUE
_wrap_RestructuringType_FULL_RESTRUCTURING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_FULL_RESTRUCTURING);
  return _val;
}


SWIGINTERN VALUE
_wrap_RestructuringType_NO_RESTRUCTURING_SPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_NO_RESTRUCTURING_SPECIFIED);
  return _val;
}


SWIGINTERN VALUE
_wrap_RestructuringType_MODIFIED_RESTRUCTURING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_RESTRUCTURING);
  return _val;
}


SWIGINTERN VALUE
_wrap_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_REAL_TIME_EXECUTION_REPORTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionID_EVENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_EVENING);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionID_AFTER_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_AFTER_HOURS);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionID_HALFDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_HALFDAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionID_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionID_MORNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_MORNING);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradingSessionID_AFTERNOON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_AFTERNOON);
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_CANCELING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_ALL_DONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALL_DONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_IN_BIDDING_PROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_IN_BIDDING_PROCESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_RECEIVED_FOR_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVED_FOR_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALERT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_RECEIVEDFOREXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVEDFOREXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_INBIDDINGPROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_INBIDDINGPROCESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_CANCELLING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELLING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListOrderStatus_EXECUTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXECUTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_REMINDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_HELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistStatus_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_AVERAGE_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingPriceDeterminationMethod_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_REGULAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ALL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ALL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejResponseTo_ORDER_CANCEL_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_BY_QUOTETYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_BY_QUOTETYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_ALL_QUOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_ALL_QUOTES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_ALL_QUOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ALL_QUOTES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SECURITY_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCancelType_CANCEL_FOR_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_YIELD_TO_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YIELD_TO_MATURITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_ALTERNATIVE_MINIMUM_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ALTERNATIVE_MINIMUM_TAX);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_GEOGRAPHICS_AND_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS_AND_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_COUPON_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_COUPON_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_BANK_QUALIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BANK_QUALIFIED);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_RATING_SOURCE_AND_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_RATING_SOURCE_AND_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_SUBSTITUTIONS_FREQUENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_FREQUENCY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MINIMUM_DENOMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_DENOMINATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MAXIMUM_ORDER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_ORDER_SIZE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTE_PREPAYMENT_SPEED);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PRICING_FREQUENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRICING_FREQUENCY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_CONSTANT_PREPAYMENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_YIELD_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YIELD_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_BENCHMARK_PRICE_SOURCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARK_PRICE_SOURCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MAXIMUM_SUBSTITUTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_SUBSTITUTIONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MONTHLY_PREPAYMENT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MONTHLY_PREPAYMENT_RATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PURPOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PURPOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WHOLE_POOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WHOLE_POOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_POOLS_MAXIMUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_MAXIMUM);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MINIMUM_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_VALUATION_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_VALUATION_DISCOUNT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_GEOGRAPHICS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_AMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AMT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_CALL_PROTECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CALL_PROTECTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_EXPLICIT_LOT_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_EXPLICIT_LOT_IDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_FREEFORM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_FREEFORM_TEXT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_TRADE_VARIANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TRADE_VARIANCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_STRUCTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_STRUCTURE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_RESTRICTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_RESTRICTED);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_CONSTANT_PREPAYMENT_PENALTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_PENALTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_TYPE_OF_REDEMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PAYMENT_FREQUENCY_CALENDAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PAYMENT_FREQUENCY_CALENDAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_ISSUERS_TICKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISSUERS_TICKER);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MAXIMUM_LOAN_BALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_LOAN_BALANCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BROKER_SALES_CREDIT_OVERRIDE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_OF_BMA_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OF_BMA_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_ISO_CURRENCY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISO_CURRENCY_CODE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MARKET_SECTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MARKET_SECTOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_POOL_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOL_IDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_TYPE_OF_ROLL_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_ROLL_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_YEAR_OF_ISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YEAR_OF_ISSUE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_LOOKBACK_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACK_DAYS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MATURITY_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_CUSTOM_START_END_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CUSTOM_START_END_DATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_ORDER_QUANTITY_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ORDER_QUANTITY_INCREMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_DISCOUNT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_DISCOUNT_RATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_CONSTANT_PREPAYMENT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_RATE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_AVERAGE_LOAN_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_LOAN_SIZE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_TRADERS_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TRADERS_CREDIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_POOLS_PER_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_LOT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_LIFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MATURITY_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_POOLS_PER_MILLION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_MILLION);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_LOT_VARIANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_LOT_VARIANCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_AVERAGE_FICO_SCORE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_FICO_SCORE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PRICE_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRICE_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MATURITY_YEAR_AND_MONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR_AND_MONTH);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_MINIMUM_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_INCREMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPON);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_SUBSTITUTIONS_LEFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_LEFT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_NUMBER_OF_PIECES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_NUMBER_OF_PIECES);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_INSURED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_INSURED);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_BARGAIN_CONDITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_POOLS_PER_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_SINGLE_MONTHLY_MORTALITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SINGLE_MONTHLY_MORTALITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_BROKERS_SALES_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BROKERS_SALES_CREDIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_ISSUE_SIZE_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISSUE_SIZE_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_BARGAIN_CONDITIONS_SEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS_SEE);
  return _val;
}


SWIGINTERN VALUE
_wrap_StipulationType_PRODUCTION_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTION_YEAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceQuoteMethod_PERCENT_OF_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_PERCENT_OF_PAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL);
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceQuoteMethod_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INDEX);
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceQuoteMethod_INTEREST_RATE_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INTEREST_RATE_INDEX);
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_COMPID_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPID_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_SIGNATURE_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATURE_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_XML_VALIDATION_ERROR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_XML_VALIDATION_ERROR));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_UNDEFINED_TAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINED_TAG));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_REQUIRED_TAG_MISSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REQUIRED_TAG_MISSING));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_DECRYPTION_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTION_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INVALID_TAG_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_TAG_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_VALUE_IS_INCORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_VALUE_IS_INCORRECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_INVALID_MSGTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_MSGTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryType_TRI_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRI_PARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryType_HOLD_IN_CUSTODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_HOLD_IN_CUSTODY));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryType_FREE_DELIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE_DELIVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeliveryType_VERSUS_PAYMENT_DELIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_VERSUS_PAYMENT_DELIVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Scope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Scope_LOCAL_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_Scope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Scope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeleteReason_CANCELLATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELLATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeleteReason_CANCELATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeleteReason_ERROR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_ERROR));
  return _val;
}


SWIGINTERN VALUE
_wrap_InViewOfCommon_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_InViewOfCommon_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_NoSides_ONE_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NoSides_ONE_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_NoSides_BOTH_SIDES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTH_SIDES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_CERTIFICATE_OF_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MUNICIPAL_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MUNICIPAL_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MORTGAGE_INTEREST_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_INTEREST_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MATURED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MATURED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FUTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FUTURE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TREASURY_BILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_BILL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BILL_OF_EXCHANGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BILL_OF_EXCHANGES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TIME_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TIME_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MORTGAGE_IOETTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_IOETTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REPURCHASE_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE_AGREEMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SPECIAL_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_COMMERCIAL_PAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIAL_PAPER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CORPORATE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORP_MORTGAGE_BACKED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_STRUCTURED_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_STRUCTURED_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REPURCHASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CANADIAN_MORTGAGE_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MORTGAGE_BONDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_REVENUE_ANTICIPATION_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_BILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PLAZOS_FIJOS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PLAZOS_FIJOS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CANADIAN_TREASURY_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_YANKEE_CORPORATE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CORPORATE_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BUY_SELLBACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BUY_SELLBACK);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_NO_ISITC_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NO_ISITC_SECURITY_TYPE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PROMISSORY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORY_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PRIVATE_EXPORT_FUNDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRIVATE_EXPORT_FUNDING);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CASH);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_DEPOSIT_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEPOSIT_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FOREIGN_EXCHANGE_CONTRACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FOREIGN_EXCHANGE_CONTRACT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SECURITIES_PLEDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_PLEDGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_RETIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_RETIRED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OVERNIGHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OVERNIGHT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REVENUE_ANTICIPATION_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_ANTICIPATION_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REVERSE_REPURCHASE_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVERSE_REPURCHASE_AGREEMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_WARRANT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WARRANT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_LIQUIDITY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITY_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MANDATORY_TENDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MANDATORY_TENDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_COMMON_STOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COMMON_STOCK);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EURO_CORPORATE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CALL_LOANS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CALL_LOANS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OPTIONS_ON_PHYSICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_PHYSICAL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REVOLVER_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_LOAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FEDERAL_AGENCY_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_COUPON);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TAX_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_ALLOCATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MISCELLANEOUS_PASS_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THROUGH);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_VARIABLE_RATE_DEMAND_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_VARIABLE_RATE_DEMAND_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MORTGAGE_PRINCIPAL_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPAL_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TAXABLE_MUNICIPAL_CP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAXABLE_MUNICIPAL_CP);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_INTEREST_RATE_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_RATE_SWAP);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BANK_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANK_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_ASSET_BACKED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_ASSET_BACKED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MULTILEG_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MULTILEG_INSTRUMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CREDIT_DEFAULT_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CREDIT_DEFAULT_SWAP);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_USD_SUPRANATIONAL_COUPONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USD_SUPRANATIONAL_COUPONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REVOLVER_TERM_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_TERM_LOAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MORTGAGE_PRINCIPLE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPLE_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REPLACED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REPLACED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_BILL_TBILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_TBILL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CERTIFICATE_OF_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SPECIAL_ASSESSMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_ASSESSMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SHORT_TERM_LOAN_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SHORT_TERM_LOAN_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_LETTER_OF_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_LETTER_OF_CREDIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OPTIONS_ON_COMBO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_COMBO);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SPECIAL_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_TAX);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PREFERRED_STOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PREFERRED_STOCK);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_NOTE_TNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_TNOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_AGENCY_POOLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_AGENCY_POOLS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MEDIUM_TERM_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MEDIUM_TERM_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CANADIAN_PROVINCIAL_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_PROVINCIAL_BONDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_IOETTE_MORTGAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_IOETTE_MORTGAGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SECURITIES_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_LOAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CERTIFICATE_OF_PARTICIPATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_PARTICIPATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FEDERAL_HOME_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOME_LOAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_CORPORATE_FLOATING_RATE_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MULTI_LEG_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MULTI_LEG_INSTRUMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_WITHDRAWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WITHDRAWN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MISCELLANEOUS_PASS_THRU_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THRU);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CANADIAN_MONEY_MARKETS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MONEY_MARKETS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FORWARD);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EURO_SUPRANATIONAL_COUPONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_SUPRANATIONAL_COUPONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EURO_SOVEREIGNS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_SOVEREIGNS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CERTIFICATE_OF_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BANK_DEPOSITORY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANK_DEPOSITORY_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_BILL_USTB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_USTB);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FX_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FX_SWAP);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_WILDCARD_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SWING_LINE_FACILITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SWING_LINE_FACILITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FEDERAL_HOUSING_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOUSING_AUTHORITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CORPORATE_PRIVATE_PLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_PRIVATE_PLACEMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_GENERAL_OBLIGATION_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_GENERAL_OBLIGATION_BONDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_INDEXED_LINKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INDEXED_LINKED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TO_BE_ANNOUNCED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TO_BE_ANNOUNCED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_NON_DELIVERABLE_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NON_DELIVERABLE_FORWARD);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OPTIONS_ON_FUTURES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_FUTURES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TAX_ANTICIPATION_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_ANTICIPATION_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TERM_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TERM_LOAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_AMENDED_RESTATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_AMENDED_RESTATED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FX_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FX_FORWARD);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CANADIAN_TREASURY_BILLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_BILLS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_DUAL_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DUAL_CURRENCY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRIVATE_PLACEMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EURO_COMMERCIAL_PAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_COMMERCIAL_PAPER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_SECURED_LIQUIDITY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURED_LIQUIDITY_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MORTGAGE_BACKED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_BACKED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_NOTE_UST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_UST);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_DEBTOR_IN_POSSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEBTOR_IN_POSSESSION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TERM_LIQUIDITY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TERM_LIQUIDITY_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_US_TREASURY_NOTE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_REVENUE_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_BONDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BRIDGE_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BRIDGE_LOAN);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CATS_TIGERS_LIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CATS_TIGERS_LIONS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BRADY_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BRADY_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_NO_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NO_SECURITY_TYPE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_DEFAULTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEFAULTED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_OTHER_ANTICIPATION_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_MUTUAL_FUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MUTUAL_FUND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_EXTENDED_COMM_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EXTENDED_COMM_NOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_CONVERTIBLE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLE_BOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_PFANDBRIEFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PFANDBRIEFE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_FX_SPOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FX_SPOT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityType_BANKERS_ACCEPTANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANKERS_ACCEPTANCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_RoundingDirection_ROUND_DOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_DOWN));
  return _val;
}


SWIGINTERN VALUE
_wrap_RoundingDirection_ROUND_TO_NEAREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_TO_NEAREST));
  return _val;
}


SWIGINTERN VALUE
_wrap_RoundingDirection_ROUND_UP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_UP));
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_MINUTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_MINUTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_WEEK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_WEEK);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_SECOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_SECOND);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_MONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_MONTH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_HOUR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_HOUR);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TimeUnit_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_YEAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_LegSwapType_MODIFIED_DURATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIED_DURATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_LegSwapType_RISK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_RISK));
  return _val;
}


SWIGINTERN VALUE
_wrap_LegSwapType_PAR_FOR_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PAR_FOR_PAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_LegSwapType_PROCEEDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PROCEEDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOITransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOITransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOITransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOITransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOITransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOITransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqResult_VALID_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALID_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstMode_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstMode_REQUEST_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REQUEST_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PreviouslyReported_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_PreviouslyReported_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_PEGGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEGGED);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_MARKET_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_SCALE);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_FILL_OR_KILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FILL_OR_KILL);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ALL_OR_NONE);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_DIRECTED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DIRECTED_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_OVER_THE_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OVER_THE_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_ADD_ON_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ADD_ON_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_MARKET_AT_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_LIMIT_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_CASH_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CASH_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_MARKET_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_TIME_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TIME_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_LIMIT_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_TRAILING_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRAILING_STOP);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_WORK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_WORK);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_RESERVE_SIZE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_RESERVE_SIZE_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_MINIMUM_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MINIMUM_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_MARKET_AT_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_IMBALANCE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMBALANCE_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityStatus_INACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityStatus_INACTIVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityStatus_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityStatus_ACTIVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_SOFT_DOLLAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_PLAN_SPONSOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLAN_SPONSOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_STEP_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_IN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_REGULAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_SOFT_DOLLAR_STEP_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR_STEP_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_STEP_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_OUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessCode_SOFT_DOLLAR_STEP_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR_STEP_IN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRY_TO_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRY_TO_STOP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PEG_TO_LIMIT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEG_TO_LIMIT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_DURATION_NEUTRAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_REINSTATE_ON_TRADING_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_TRADING_HALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NO_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NO_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PEGVWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEGVWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STRICT_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_SCALE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_AON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_AON));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_MARKPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKPEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_MIDPRCPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MIDPRCPEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_OKCROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OKCROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRAILING_STOP_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRAILING_STOP_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_EXECUTE_AS_FX_NEUTRAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_FX_NEUTRAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CUSTDISPINST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTDISPINST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_OK_TO_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OK_TO_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_SYSTEM_FAILURE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_GO_ALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_GO_ALONG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_INSTITONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_DO_NOT_INCREASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_DO_NOT_INCREASE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_SUSPEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRYTOSTOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSTOP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_SYSTEM_FAILURE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_SUSPEND_ON_TRADING_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_TRADING_HALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_INTERMARKET_SWEEP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_INTERMARKET_SWEEP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_BEST_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_BEST_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PARTICIPATE_DONT_INITIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTICIPATE_DONT_INITIATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_LASTPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_LASTPEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PEG_TO_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEG_TO_VWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PRIMARY_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMARY_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NONNEGO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NONNEGO));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_IGNORE_PRICE_VALIDITY_CHECKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STAY_ON_BID_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_BID_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NOTHELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOTHELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STRICTSCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICTSCALE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_REINSTATE_ON_CONNECTION_LOSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_CONNECTION_LOSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_DNI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNI));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRYTOSCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSCALE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PERCENT_OF_VOLUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCENT_OF_VOLUME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_GOALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_GOALONG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_WORK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_HELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NOCROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOCROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_RELEASE_FROM_SUSPENSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_RELEASE_FROM_SUSPENSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STRICT_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_OPENPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENPEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STAY_ON_BIDSIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_BIDSIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STAY_ON_OFFERSIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_OFFERSIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_OVER_THE_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVER_THE_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_RESTATEONTRADINGHALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONTRADINGHALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_INSTITUTIONS_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITUTIONS_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOT_HELD));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CANCELONTRADINGHALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONTRADINGHALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CANCELONSYSFAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONSYSFAIL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_MARKET_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKET_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRADEALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADEALONG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CALL_FIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALL_FIRST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CANCEL_ON_SYSTEM_FAILURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_SYSTEM_FAILURE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NON_NEGOTIABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NON_NEGOTIABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRY_TO_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRY_TO_SCALE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_EXTERNAL_ROUTING_ALLOWED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXTERNAL_ROUTING_ALLOWED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STAY_ON_OFFER_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_OFFER_SIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTOMER_DISPLAY_INSTRUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_WORK_TO_TARGET_STRATEGY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK_TO_TARGET_STRATEGY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_OVERDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVERDAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_LAST_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_LAST_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CALLFIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALLFIRST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_REINSTATE_ON_SYSTEM_FAILUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_SYSTEM_FAILUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_DO_NOT_REDUCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_DO_NOT_REDUCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_MID_PRICE_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MID_PRICE_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_ALL_OR_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_OPENING_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENING_PEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PERCVOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCVOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_SUSPEND_ON_CONNECTION_LOSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_CONNECTION_LOSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CANCEL_ON_CONNECTION_LOSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_CONNECTION_LOSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CANCEL_IF_NOT_BEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_IF_NOT_BEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PARTNOTINIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTNOTINIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NETTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_IMBALANCE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_IMBALANCE_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_DNR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNR));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STAYOFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYOFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_STAYBID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYBID));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_TRADE_ALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADE_ALONG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_CANCEL_ON_TRADING_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_TRADING_HALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_RESTATEONSYSFAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONSYSFAIL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecInst_PRIMPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMPEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_PENDING_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_TRADE_IN_A_CLEARING_HOLD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_IN_A_CLEARING_HOLD));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_ORDER_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDER_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_PENDING_CANCEL_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_PARTIAL_FILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PARTIAL_FILL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_PENDING_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_STOPPED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_CANCELED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_PENDING_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_TRADE_CORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CORRECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_SUSPENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_SUSPENDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_FILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_FILL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_RESTATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_RESTATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_REPLACED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_DONE_FOR_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_DONE_FOR_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_TRADE_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecType_CANCELLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELLED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegModel_USER_DEFINED_MULTLEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegModel_USER_DEFINED_MULTLEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegModel_PREDEFINED_MULTILEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegModel_PREDEFINED_MULTILEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_SWAP_NEXT_START_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_NEXT_START_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_LAST_ELIGIBLE_TRADE_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_ELIGIBLE_TRADE_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_FIRST_DELIVERY_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_DELIVERY_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_TENDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_TENDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_INITIAL_INVENTORY_DUE_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_INITIAL_INVENTORY_DUE_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_FIRST_INTENT_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_INTENT_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_ACTIVATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_ACTIVATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_PUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_SWAP_START_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_START_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_SWAP_NEXT_ROLL_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_NEXT_ROLL_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_LAST_DELIVERY_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_DELIVERY_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_POSITION_REMOVAL_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_POSITION_REMOVAL_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_SWAP_ROLL_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_ROLL_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_FINAL_INVENTORY_DUE_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_FINAL_INVENTORY_DUE_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_INACTIVIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_INACTIVIATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_SWAP_END_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_END_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_LAST_INTENT_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_INTENT_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_SINKING_FUND_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SINKING_FUND_CALL));
  return _val;
}


SWIGINTERN VALUE
_wrap_EventType_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_CALL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeAllocIndicator_ALLOCATION_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_NOT_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_NOT_LOGGED_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_NOT_LOGGED_IN));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_PASSWORD_INCORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_INCORRECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_LOGGED_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGED_IN));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_USER_NOT_RECOGNISED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_USER_NOT_RECOGNISED));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_PASSWORD_CHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_CHANGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_UserStatus_SESSION_SHUTDOWN_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_SESSION_SHUTDOWN_WARNING));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_WEEKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_WEEKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_TENTHS_OF_A_SECOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_TENTHS_OF_A_SECOND));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_SECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_SECONDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_MONTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MONTHS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_YEARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_YEARS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_NANOSECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_NANOSECONDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HUNDREDTHS_OF_A_SECOND));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HOURS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_MICROSECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MICROSECONDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_MINUTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MINUTES));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_MILLISECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MILLISECONDS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrderDelayUnit_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_DAYS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradedFlatSwitch_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradedFlatSwitch_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRptStatus_ACCEPTED_WITH_ERRORS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED_WITH_ERRORS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRptStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TrdRptStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_PENDING_END_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING_END_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CROSS_MARKET_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CROSS_MARKET_WARNING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_LOCKED_MARKET_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_LOCKED_MARKET_WARNING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_FOR_UNDERLYING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_UNDERLYING));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_TOO_LATE_TO_END_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_TOO_LATE_TO_END));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_SECURITY_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_ALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_ALL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_PASS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PASS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_QUERY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUERY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCELED_FOR_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_REMOVED_FROM_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REMOVED_FROM_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACTIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_CANCEL_FOR_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCEL_FOR_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteStatus_QUOTE_NOT_FOUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUOTE_NOT_FOUND));
  return _val;
}


SWIGINTERN VALUE
_wrap_SolicitedFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_SolicitedFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_DEALER_SOLD_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALER_SOLD_SHORT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegRoundDirection_MORE_AGGRESSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegRoundDirection_MORE_PASSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_ModelType_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ModelType_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ModelType_UTILITY_PROVIDED_STANDARD_MODEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_FuturesValuationMethod_PREMIUM_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FuturesValuationMethod_PREMIUM_STYLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlMethod_CASH_SETTLEMENT_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlMethod_CASH_SETTLEMENT_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmStatus_CONFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_CONFIRMED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmStatus_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmStatus_MISMATCHED_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHED_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmStatus_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
_wrap_LocateReqd_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LocateReqd_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_LocateReqd_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LocateReqd_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_Adjustment_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Adjustment_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Adjustment_CORRECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Adjustment_CORRECTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Adjustment_ERROR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Adjustment_ERROR));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnType_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_ASSIGNMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnType_TERMINATE_UNASSIGN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_TERMINATE_UNASSIGN));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnType_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastRptRequested_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastRptRequested_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlSessID_END_OF_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_END_OF_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlSessID_ELECTRONIC_TRADING_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_ELECTRONIC_TRADING_HOURS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlSessID_REGULAR_TRADING_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_REGULAR_TRADING_HOURS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlSessID_INTRADAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_INTRADAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_LOCKED_IN_TRADE_BREAK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_LOCKED_IN_TRADE_BREAK));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_NO_WAS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NO_WAS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ADDENDUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ADDENDUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_7_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_7));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_PENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_PENDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_DEFAULTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DEFAULTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_DECLINE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DECLINE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_TRADE_REPORT_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_15_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_15));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_ADDENDUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_ADDENDUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_SUBMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_SUBMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_1));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_INVALID_CMTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_INVALID_CMTA));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ALLEGED_NO_WAS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NO_WAS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_TRADE_REPORT_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_TRADE_REPORT_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeReportType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExerciseStyle_AMERICAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_AMERICAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExerciseStyle_EUROPEAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_EUROPEAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExerciseStyle_BERMUDA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_BERMUDA));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_ADDITIONAL_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDITIONAL_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_NEW_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEW_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_ORDER_INFLUX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_INFLUX));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_DISSEMINATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_EQUIPMENT_CHANGEOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPMENT_CHANGEOVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_HaltReasonChar_ORDER_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestination_POSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestination_POSIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExDestination_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestination_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_WAREHOUSE_RECAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSE_RECAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_ACCEPT_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_COMPLETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_COMPLETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_REQUEST_TO_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REQUEST_TO_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_REVERSE_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REVERSE_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocReportType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_INCOMPLETE_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_INCOMPLETE_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_REVERSAL_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_REVERSAL_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_ACCEPT_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_BUYSIDE_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_REQUEST_TO_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_REQUEST_TO_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_BUYSIDE_READY_TO_BOOK_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK_5));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_BUYSIDE_READY_TO_BOOK_6_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK_6));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_COMPLETE_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_COMPLETE_GROUP));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_BUYSIDE_READY_TO_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_READY_TO_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_READY_TO_BOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_WAREHOUSE_INSTRUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSE_INSTRUCTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_BUYSIDE_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INSUFFICIENT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_INVALID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVALID_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_TOO_LATE_TO_ENTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_PASS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_PASS));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_NO_INVENTORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_INVENTORY));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_LiquidityIndType_20_DAY_MOVING_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_20_DAY_MOVING_AVERAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_LiquidityIndType_5_DAY_MOVING_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_5_DAY_MOVING_AVERAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_LiquidityIndType_5DAY_MOVING_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_5DAY_MOVING_AVERAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_LiquidityIndType_NORMAL_MARKET_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_NORMAL_MARKET_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_LiquidityIndType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatusValue_IN_PROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_IN_PROCESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatusValue_NOT_CONNECTED_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_2));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatusValue_CONNECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_CONNECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_StatusValue_NOT_CONNECTED_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_EXCHANGE_FOR_PHYSICAL_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_EXCHANGE_FOR_PHYSICAL_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_TRANSFER_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSFER_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_INTER_SPREAD_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTER_SPREAD_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_INTRA_SPREAD_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTRA_SPREAD_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_START_OF_DAY_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_START_OF_DAY_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_DELIVERY_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_DELIVERY_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_PIT_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_PIT_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_TRANSACTION_FROM_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_ASSIGNMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_TRANSACTION_FROM_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_EXERCISE);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_OPTION_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_OPTION_ASSIGNMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_AS_OF_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_AS_OF_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_ELECTRONIC_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ELECTRONIC_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_SUCCESSION_EVENT_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_SUCCESSION_EVENT_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_OPTION_EXERCISE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_OPTION_EXERCISE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_TRANSACTION_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_NET_DELTA_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_NET_DELTA_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_DELIVERY_NOTICE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_DELIVERY_NOTICE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_TOTAL_TRANSACTION_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TOTAL_TRANSACTION_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_ADJUSTMENT_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENT_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_END_OF_DAY_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_END_OF_DAY_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_RECEIVE_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_RECEIVE_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_CREDIT_EVENT_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CREDIT_EVENT_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_PRIVATELY_NEGOTIATED_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_CORPORATE_ACTION_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CORPORATE_ACTION_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_CROSS_MARGIN_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CROSS_MARGIN_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_INTEGRAL_SPLIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTEGRAL_SPLIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosType_ALLOCATION_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ALLOCATION_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnAckType_ASSIGNMENT_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeBasis_ABSOLUTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_ABSOLUTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeBasis_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MiscFeeBasis_PER_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PER_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_PREVIOUSLY_QUOTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_PREVIOUSLY_QUOTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_PREVIOUS_FUND_VALUATION_POINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUS_FUND_VALUATION_POINT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_PEGGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PEGGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_LIMIT_WITH_OR_WITHOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_WITH_OR_WITHOUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_STOP_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_SWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_PREVIOUSLY_QUOTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_QUOTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_COUNTER_ORDER_SELECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_COUNTER_ORDER_SELECTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_MARKET_IF_TOUCHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_IF_TOUCHED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_NEXT_FUND_VALUATION_POINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_NEXT_FUND_VALUATION_POINT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_C_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_C));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FUNARI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FUNARI));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_F_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_F));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_PREVIOUSLY_INDICATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_INDICATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_WITH_OR_WITHOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_WITH_OR_WITHOUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_MARKET_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_ON_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_G_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_G));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_LIMIT_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_ON_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_FOREX_H_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_H));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_ON_BASIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_BASIS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_LIMIT_OR_BETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_OR_BETTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_OrdType_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_NON_ACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NON_ACT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_AUTO_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_AUTO_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CALL_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ACT_M2_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_M2_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ONE_PARTY_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ACT_M1_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_M1_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_COUNTER_ORDER_SELECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ISSUING_BUY_BACK_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ISSUING_BUY_BACK_AUCTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CROSS_AUCTION_63_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_63);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CROSS_AUCTION_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_5);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CALL_AUCTION_7_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_7);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_COUNTER_ORDER_SELECTION_64_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_64);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_TWO_PARTY_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ACT_DEFAULT_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ACT_ACCEPTED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_ACCEPTED_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_COUNTER_ORDER_SELECTION_6_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_6);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CROSS_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CALL_AUCTION_65_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_65);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CONFIRMED_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CONFIRMED_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ACT_M6_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_M6_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_CONTINUOUS_AUTO_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CONTINUOUS_AUTO_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_OCS_LOCKED_IN_NON_ACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_OCS_LOCKED_IN_NON_ACT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2);
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchType_ACT_DEFAULT_AFTER_M2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_AFTER_M2);
  return _val;
}


SWIGINTERN VALUE
_wrap_OptPayoutType_BINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_BINARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OptPayoutType_VANILLA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_VANILLA));
  return _val;
}


SWIGINTERN VALUE
_wrap_OptPayoutType_CAPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_CAPPED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MarketUpdateAction_DELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_DELETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MarketUpdateAction_ADD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_ADD));
  return _val;
}


SWIGINTERN VALUE
_wrap_MarketUpdateAction_MODIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_MODIFY));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_UNKNOWN_DEAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_DEAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENT_COLLATERAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_IndividualAllocType_SUB_ALLOCATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_SUB_ALLOCATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_IndividualAllocType_THIRD_PARTY_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_THIRD_PARTY_ALLOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES));
  return _val;
}


SWIGINTERN VALUE
_wrap_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES));
  return _val;
}


SWIGINTERN VALUE
_wrap_PutOrCall_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PutOrCall_PUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PutOrCall_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PutOrCall_CALL));
  return _val;
}


SWIGINTERN VALUE
_wrap_FundRenewWaiv_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_FundRenewWaiv_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_ForexReq_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ForexReq_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_ForexReq_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ForexReq_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickRuleType_TRADED_AS_A_SPREAD_LEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_TRADED_AS_A_SPREAD_LEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickRuleType_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_REGULAR));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickRuleType_VARIABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_VARIABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickRuleType_SETTLED_AS_A_SPREAD_LEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_SETTLED_AS_A_SPREAD_LEG));
  return _val;
}


SWIGINTERN VALUE
_wrap_TickRuleType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_FIXED));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionOffsetType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionOffsetType_PRICE_TIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE_TIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionOffsetType_TICKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_TICKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionOffsetType_BASIS_POINTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASIS_POINTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_ConfirmTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDSecSizeType_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesEvent_CHANGE_OF_TRADING_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesEvent_CHANGE_OF_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_SUBSESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesEvent_TRADING_RESUMES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_TRADING_RESUMES));
  return _val;
}


SWIGINTERN VALUE
_wrap_DlvyInstType_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_DlvyInstType_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_CASH));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_IMPLIED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMPLIED_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OPENING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_PRIOR_REFERENCE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_PRIOR_REFERENCE_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_LAST_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SELLER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SELLER);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_DISTRIBUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_DISTRIBUTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_NEXT_DAY_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STRADDLE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CROSSED_AO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_AO);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SOLD_LAST_SALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OPENED_SALE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENED_SALE_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_REOPEN_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SOLD_LAST_SALE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STOPPED_SOLD_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_SOLD_LAST);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_FORM_T_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_FORM_T);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_ADJUSTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OUT_OF_SEQUENCE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OUT_OF_SEQUENCE_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_COMBO_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_COMBO_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_ONLY_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STRADDLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OUTSIDE_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OUTSIDE_SPREAD);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_BUNCHED_SALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED_SALE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_LATE_OPEN_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_LATE_OPEN_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_REOPENING_TRADE_DETAIL);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_COMBO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_COMBO);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OPENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENING);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_ACQUISITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_ACQUISITION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OPENED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENED);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_NEXT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_BARGAIN_CONDITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BARGAIN_CONDITION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CONVERTED_PRICE_INDICATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CONVERTED_PRICE_INDICATOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OFFICIAL_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OFFICIAL_CLOSING_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_ADJUSTED_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_RULE_155_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_RULE_155_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_AUTOMATIC_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AUTOMATIC_EXECUTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CROSSED_X_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_X);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_AUTO_EXECUTION_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AUTO_EXECUTION_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_MULTILEG_TO_MULTILEG_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_BASKET_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BASKET_INDEX);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_FINAL_PRICE_OF_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_FINAL_PRICE_OF_SESSION);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STOPPED_STOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_STOCK);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_OFFICAL_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OFFICAL_CLOSING_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CASH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_REGULAR_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_REGULAR_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STOPPED_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_VOLUME_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_VOLUME_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_STOPPED_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_STOPPED_OUT_OF_SEQUENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_OUT_OF_SEQUENCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CASH_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CASH_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SPLIT_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SPLIT_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_IMBALANCE_MORE_BUYERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_BUYERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_IMBALANCE_MORE_SELLERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_SELLERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_INTRADAY_TRADE_DETAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY_TRADE_DETAIL);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_RULE_127_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_RULE_127_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_BUNCHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_REOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_EX_PIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_EX_PIT);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_DIRECT_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_DIRECT_PLUS);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_AVERAGE_PRICE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AVERAGE_PRICE_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SOLD_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_MARKETPLACE_ENTERED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_MARKETPLACE_ENTERED_TRADE);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SPREAD_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_CANCEL_OPEN_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_EXCHANGE_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_EXCHANGE_LAST);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_FAST_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_FAST_MARKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_BURST_BASKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BURST_BASKET);
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeCondition_SOLD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD);
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceLimitType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceLimitType_TICKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_TICKS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriceLimitType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PER_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PER_SHARE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_ABSOLUTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_ABSOLUTE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PER_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PER_BOND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PERCENTAGE_WAIVED_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE_WAIVED_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_POINTS_PER_BOND_OR_CONTRACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_POINTS_PER_BOND_OR_CONTRACT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PERCENTAGE_WAIVED_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE_WAIVED_5));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PER_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PER_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_CommType_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_5));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS));
  return _val;
}


SWIGINTERN VALUE
_wrap_FinancialStatus_BANKRUPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_BANKRUPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_FinancialStatus_RESTRICTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_RESTRICTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_FinancialStatus_PENDING_DELISTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDING_DELISTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastFragment_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastFragment_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastFragment_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastFragment_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_NotifyBrokerOfCredit_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_NotifyBrokerOfCredit_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_DEPARTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DEPARTMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_FAX_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAX_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_CASH_ACCOUNT_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASH_ACCOUNT_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_REGISTERED_ADDRESS_12_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTERED_ADDRESS_12));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_CONTACT_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACT_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_PERSON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PERSON));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_SECURITY_LOCATE_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITY_LOCATE_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_POSITION_ACCOUNT_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSITION_ACCOUNT_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_CASH_ACCOUNT_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASH_ACCOUNT_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_POSTAL_ADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTAL_ADDRESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_PROFESSIONAL_CLIENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PROFESSIONAL_CLIENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_FUND_ACCOUNT_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FUND_ACCOUNT_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_REGISTRATION_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_REGULATORY_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORY_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_TELEX_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEX_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_REGISTERED_ADDRESS_18_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTERED_ADDRESS_18));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_BIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_REGISTRATION_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_EMAIL_ADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAIL_ADDRESS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_LOCATION_DESK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION_DESK));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_APPLICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_APPLICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_SECURITIES_ACCOUNT_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIES_ACCOUNT_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_PHONE_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONE_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_ELIGIBLE_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ELIGIBLE_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_EXECUTION_VENUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EXECUTION_VENUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIES_ACCOUNT_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FULL_LEGAL_NAME_OF_FIRM));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_EXPLICIT_LIST_PROVIDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocNoOrdersType_NOT_SPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOT_SPECIFIED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocLinkType_FX_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_SWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocLinkType_F_X_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_F_X_NETTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocLinkType_FX_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_NETTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocLinkType_F_X_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_F_X_SWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingSettlementType_T_PLUS_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS_1));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingSettlementType_T_PLUS_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingSettlementType_T_PLUS_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS_4));
  return _val;
}


SWIGINTERN VALUE
_wrap_DisplayMethod_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_DisplayMethod_UNDISCLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_UNDISCLOSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_DisplayMethod_RANDOM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_RANDOM));
  return _val;
}


SWIGINTERN VALUE
_wrap_DisplayMethod_INITIAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_INITIAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollStatus_PARTIALLY_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLY_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollStatus_ASSIGNMENT_PROPOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENT_PROPOSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollStatus_CHALLENGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_CHALLENGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollStatus_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollStatus_UNASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_UNASSIGNED));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideValueInd_SIDEVALUE_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE_2));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideValueInd_SIDEVALUE1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE1));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideValueInd_SIDE_VALUE_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDE_VALUE_1));
  return _val;
}


SWIGINTERN VALUE
_wrap_SideValueInd_SIDE_VALUE_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDE_VALUE_2));
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgDirection_RECEIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MsgDirection_RECEIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MsgDirection_SEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MsgDirection_SEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateAction_DELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateAction_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateAction_DELETE_THRU_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_THRU));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateAction_DELETE_FROM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_FROM));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateAction_OVERLAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_OVERLAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDUpdateAction_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_CHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_COMPARED_MATCHED_OR_AFFIRMED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchStatus_ADVISORY_OR_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_ADVISORY_OR_ALERT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED));
  return _val;
}


SWIGINTERN VALUE
_wrap_RateSource_REUTERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_REUTERS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RateSource_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_RateSource_BLOOMBERG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_BLOOMBERG));
  return _val;
}


SWIGINTERN VALUE
_wrap_RateSource_TELERATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_TELERATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocPositionEffect_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocPositionEffect_FIFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_FIFO));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocPositionEffect_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocPositionEffect_ROLLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_ROLLED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_TAIWANESE_TRADING_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_TRADING_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_TAIWANESE_TRADING_ACCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_TRADING_ACCT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_SOCIAL_SECURITY_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SETTLEMENT_ENTITY_LOCATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_PROPRIETARY_CUSTOM_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY_CUSTOM_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_BIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_CHINESE_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESE_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_MIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_KOREAN_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_KOREAN_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_ISO_COUNTRY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ISO_COUNTRY_CODE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PartyIDSource_CHINESE_B_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESE_B_SHARE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExchangeForPhysical_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExchangeForPhysical_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_TRADING_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_BOOK_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_TRADING_RESUMES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_TRADING_RESUMES));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAction_ADD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAction_ADD));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAction_REMOVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAction_REMOVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CollAction_RETAIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAction_RETAIN));
  return _val;
}


SWIGINTERN VALUE
_wrap_PossDupFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_PossDupFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_ALL_DONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALL_DONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_TIMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_TIMED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_EXECSTARTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXECSTARTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_RESPONSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESPONSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_ALLDONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALLDONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALERT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_ACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ACK));
  return _val;
}


SWIGINTERN VALUE
_wrap_ListStatusType_EXEC_STARTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXEC_STARTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_GapFillFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_GapFillFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeHandlingInstr_TWO_PARTY_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TWO_PARTY_REPORT));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeHandlingInstr_TRADE_CONFIRMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TRADE_CONFIRMATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesMethod_ELECTRONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_ELECTRONIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesMethod_TWO_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWO_PARTY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradSesMethod_OPEN_OUTCRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPEN_OUTCRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeType_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_AGENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeType_VWAP_GUARANTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_VWAP_GUARANTEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeType_RISK_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_RISK_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TradeType_GUARANTEED_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_GUARANTEED_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventCondition_AND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_AND));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventCondition_OR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_OR));
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_SONIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SONIA);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_MUNIAAA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MUNIAAA);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_LIBID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBID);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_PFANDBRIEFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PFANDBRIEFE);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_EUREPO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EUREPO);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_FUTURESWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FUTURESWAP);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_TREASURY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TREASURY);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_OTHER);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_EURIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EURIBOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_EONIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EONIA);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_LIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_BenchmarkCurveName_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SWAP);
  return _val;
}


SWIGINTERN VALUE
_wrap_CashMargin_MARGIN_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CashMargin_MARGIN_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_CashMargin_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_CASH));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligTransType_RESTATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_RESTATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlObligTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_PEGGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_PEGGED);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_MARKET_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_SCALE);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_FILL_OR_KILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_FILL_OR_KILL);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ALL_OR_NONE);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_DIRECTED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_DIRECTED_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_OVER_THE_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_OVER_THE_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_ADD_ON_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ADD_ON_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_MARKET_AT_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_LIMIT_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_CASH_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_CASH_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_MARKET_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_TIME_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TIME_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_LIMIT_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_TRAILING_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TRAILING_STOP);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_WORK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_WORK);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_RESERVE_SIZE_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_MINIMUM_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MINIMUM_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_MARKET_AT_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_IMBALANCE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMBALANCE_ONLY);
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosTransType_DO_NOT_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_DO_NOT_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosTransType_LARGE_TRADER_SUBMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_LARGE_TRADER_SUBMISSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosTransType_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosTransType_PLEDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_PLEDGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosTransType_POSITION_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_ADJUSTMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_Seniority_SUBORDINATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::Seniority_SUBORDINATED);
  return _val;
}


SWIGINTERN VALUE
_wrap_Seniority_SENIOR_SECURED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::Seniority_SENIOR_SECURED);
  return _val;
}


SWIGINTERN VALUE
_wrap_Seniority_SENIOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::Seniority_SENIOR);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlCurrFxRateCalc_DIVIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_DIVIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlCurrFxRateCalc_MULTIPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_MULTIPLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintStatus_ACCEPTED_WITH_WARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED_WITH_WARNINGS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintStatus_COMPLETED_WITH_WARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED_WITH_WARNINGS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_6_MO_LIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_6_MO_LIBOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_OLD_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_5));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_OLD_30_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_30));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_3_MO_LIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_3_MO_LIBOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_OLD_10_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_10));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_CURVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_30_YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_30_YR));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_10_YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_10_YR));
  return _val;
}


SWIGINTERN VALUE
_wrap_Benchmark_5_YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_5_YR));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearFormat_YEARMONTHWEEK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHWEEK));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearFormat_YEARMONTHDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHDAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaturityMonthYearFormat_YEARMONTH_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTH_ONLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_LegalConfirm_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_LegalConfirm_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID));
  return _val;
}


SWIGINTERN VALUE
_wrap_ReportToExch_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ReportToExch_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_ReportToExch_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ReportToExch_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_ALLOCATED_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_UNKNOWN_ORDERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ORDERID));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_INCORRECT_AVERAGEG_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_AVERAGEG_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_WAREHOUSE_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_OTHER_99_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_99));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_UNKNOWN_LISTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_LISTID));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_INCORRECT_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_INCORRECT_AVERAGE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_AVERAGE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_UNKNOWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_UNKNOWN_OR_STALE_EXECID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_OR_STALE_EXECID));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_MISMATCHED_DATA_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_OTHER_7_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_7));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_UNKNOWN_CLORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_CLORDID));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_MISMATCHED_DATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_CALCULATION_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATION_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_COMMISSION_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMISSION_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_GTC_FROM_PREVIOUS_DAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrdIDReason_PARTIAL_FILL_REMAINING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_PARTIAL_FILL_REMAINING));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrdIDReason_ORDER_CHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_ORDER_CHANGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_SECONDARYORDERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDERID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_ORDERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDERID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_MDENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MDENTRYID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_ORIGINAL_ORDER_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORIGINAL_ORDER_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_MENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MENTRYID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_QUOTEENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTEENTRYID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_QUOTENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTENTRYID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_ORDEID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDEID));
  return _val;
}


SWIGINTERN VALUE
_wrap_RefOrderIDSource_SECONDARYORDEID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDEID));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastCapacity_CROSS_AS_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_CROSS_AS_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastCapacity_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastCapacity_CROSS_AS_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_CROSS_AS_AGENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_LastCapacity_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_AGENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_INSTRUMENT_STRIKE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_STRIKE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_IN_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_IN_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_PRE_REFUNDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRE_REFUNDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINAL_ISSUE_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_UNRATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_UNRATED));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_WHEN_AND_IF_ISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_WHEN_AND_IF_ISSUED));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_STEPPED_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPED_COUPON));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_INSTRUMENT_DENOMINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_DENOMINATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_REDEMPTION_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_TAXABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TAXABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_INTEREST_BEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTEREST_BEARING));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_PREREFUNDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PREREFUNDED));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_CALLABLE_PUTTABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_PUTTABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_COUPON_PERIOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPON_PERIOD));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_INSTRUMENT_PRICE_PRECISION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_PRICE_PRECISION));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_TRADEABLE_INDICATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADEABLE_INDICATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_VARIABLE_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLE_RATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_FLAT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_FLAT));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_INSTRUMENT_NUMERATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_NUMERATOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_INDEXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEXED));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_ESCROWED_TO_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_MATURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_LESS_FEE_FOR_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_LESS_FEE_FOR_PUT));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_ZERO_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZERO_COUPON));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_InstrAttribType_NO_PERIODIC_PAYMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NO_PERIODIC_PAYMENTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_FINANCING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_FINANCING));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_COMMODITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_COMMODITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_EQUITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_EQUITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_CORPORATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_CORPORATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_AGENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_MONEYMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_MONEYMARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_MORTGAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_MORTGAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_CURRENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_INDEX));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_MUNICIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_MUNICIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_LOAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_Product_GOVERNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_GOVERNMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_FAST_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FAST_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NO_OPEN_NO_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN_NO_RESUME));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_TRADING_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_HALT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NO_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_RESUME));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADE_DISSEMINATION_TIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_POST_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_POST_CLOSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_MARKET_IMBALANCE_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_IMBALANCE_SELL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_OPENING_DELAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_DELAY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_ITS_PRE_OPENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_ITS_PRE_OPENING));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_PRE_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_CROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_PRE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_MARKET_IMBALANCE_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_IMBALANCE_BUY));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_TRADING_RANGE_INDICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_RANGE_INDICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_READY_TO_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_READY_TO_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NEW_PRICE_INDICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NEW_PRICE_INDICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_OPENING_ROTATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_ROTATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_PRICE_INDICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRICE_INDICATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_UNKNOWN_OR_INVALID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_UNKNOWN_OR_INVALID));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL));
  return _val;
}


SWIGINTERN VALUE
_wrap_SecurityTradingStatus_NO_MARKET_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_MARKET_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SPECIALIST_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_F_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_F));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_COMPETING_DEALER_TRADES_O_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETING_DEALER_TRADES_O));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_H_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_H));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_COMPETING_DEALER_TRADES_R_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETING_DEALER_TRADES_R));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_COMPETING_DEALER_TRADES_T_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETING_DEALER_TRADES_T));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_B_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_B));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_AGENCY_SINGLE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_SINGLE_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_MERGER_REORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_MERGER_REORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_SYMBOL_CONVERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SYMBOL_CONVERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_SUCCESSION_EVENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SUCCESSION_EVENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_STOCK_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STOCK_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_REVERSE_STOCK_SPLIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_REVERSE_STOCK_SPLIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_POSITION_CONSOLIDATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_POSITION_CONSOLIDATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_SPINOFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPINOFF));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_EX_INTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_INTEREST));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_LIQUIDATION_REORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LIQUIDATION_REORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_CASH_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CASH_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STANDARD_INTEGER_STOCK_SPLIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_RIGHTS_OFFERING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_RIGHTS_OFFERING));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_SHAREHOLDER_MEETING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SHAREHOLDER_MEETING));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_WARRANT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_WARRANT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_EX_RIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_RIGHTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_EX_DISTRIBUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DISTRIBUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_EX_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_TENDER_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_TENDER_OFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_SPECIAL_ACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPECIAL_ACTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_NON_INTEGER_STOCK_SPLIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NON_INTEGER_STOCK_SPLIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_CUSIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CUSIP));
  return _val;
}


SWIGINTERN VALUE
_wrap_CorporateAction_LEAP_ROLLOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LEAP_ROLLOVER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerminationType_TERM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_TERM));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerminationType_FLEXIBLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_FLEXIBLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerminationType_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_OPEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerminationType_OVERNIGHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_OVERNIGHT));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_REVERSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REVERSE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_SPECIFIED_DATE_TIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceTimeType_EXPIRATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_EXPIRATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ComplexEventPriceTimeType_IMMEDIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_IMMEDIATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingFXRateCalc_DIVIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_DIVIDE));
  return _val;
}


SWIGINTERN VALUE
_wrap_UnderlyingFXRateCalc_MULTIPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_MULTIPLY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OddLot_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OddLot_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_OddLot_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OddLot_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER));
  return _val;
}


SWIGINTERN VALUE
_wrap_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_REJECTED_BY_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED_BY_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_BLOCK_LEVEL_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_BLOCK_LEVEL_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_ACCOUNT_LEVEL_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCOUNT_LEVEL_REJECT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_INCOMPLETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_INCOMPLETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_ALLOCATION_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ALLOCATION_PENDING));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_REVERSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REVERSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_PARTIAL_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_PARTIAL_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_AllocStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_IncTaxInd_NET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_NET));
  return _val;
}


SWIGINTERN VALUE
_wrap_IncTaxInd_GROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_GROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PosReqStatus_COMPLETED_WITH_WARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED_WITH_WARNINGS));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriorityIndicator_PRIORITY_UNCHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITY_UNCHANGED));
  return _val;
}


SWIGINTERN VALUE
_wrap_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_NOT_CHECKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOT_CHECKED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_PASSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_PASSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_EXEMPT_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_1));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_EXEMPT_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_2));
  return _val;
}


SWIGINTERN VALUE
_wrap_MoneyLaunderingStatus_EXEMPT_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_3));
  return _val;
}


SWIGINTERN VALUE
_wrap_LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE));
  return _val;
}


SWIGINTERN VALUE
_wrap_LotType_ROUND_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT));
  return _val;
}


SWIGINTERN VALUE
_wrap_LotType_ODD_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_ODD_LOT));
  return _val;
}


SWIGINTERN VALUE
_wrap_LotType_BLOCK_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_BLOCK_LOT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_FLAT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FLAT_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_REST_OF_BOOK_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_REST_OF_BOOK_VWAP);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_TRADING_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RANGE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_HALT_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_HALT_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_BID_OFFER_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_BID_OFFER_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_CROSSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CROSSED);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_NO_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NO_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_HALT);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_PREOPENING_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_PREOPENING_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OPEN_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_RESERVED_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_RESERVED_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OUTRIGHT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OUTRIGHT_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_IMPLIED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_IMPLIED_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_DEPTH_ON_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_OFFER);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_REGULAR_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_REGULAR_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_ROTATION_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_EXCHANGE_BEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHANGE_BEST);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_DEPTH_ON_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_BID);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_CLOSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSING);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_VIEW_OF_COMMON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_VIEW_OF_COMMON);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_FORBIDDEN_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FORBIDDEN_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_LOCKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_LOCKED);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_ORDER_INFLUX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_INFLUX);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_PENDING);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_RESUME);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_TRADING_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RESUME);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OUT_OF_SEQUENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OUT_OF_SEQUENCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_END_OF_DAY_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_END_OF_DAY_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_FROZEN_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FROZEN_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OPENING_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPENING_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_MANUAL_SLOW_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_MANUAL_SLOW_QUOTE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_DISSEMINATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_DUE_TO_RELATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_RELATED);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_VOLUME_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_VOLUME_ALERT);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_FAST_MARKET_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_MARKET_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_INACTIVE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_INACTIVE_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_DISSEMINATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_SURVEILLANCE_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_SURVEILLANCE_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_AUTOMATIC_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_DUE_TO_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_PENDING);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_NO_ACTIVE_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NO_ACTIVE_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OFFER_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OFFER_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_SUSPENDED_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_SUSPENDED_SAM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_RESTRICTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_RESTRICTED);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_NON_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NON_FIRM);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_CLOSED_INACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED_INACTIVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_ADDITIONAL_INFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_EQUIPMENT_CHANGEOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_EQUIPMENT_CHANGEOVER);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_FAST_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_TRADING);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_FULL_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FULL_CURVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_MEDIAN_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_MEDIAN_PRICE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_OPEN_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_ACTIVE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_ORDER_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_IMBALANCE);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_AUTOMATIC_EXECUTION_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION_ETH);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_ROTATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_BID_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_BID_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_CONSOLIDATED_BEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLIDATED_BEST);
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteCondition_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_EUROCLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_EUROCLEAR);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_CEDEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_CEDEL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_PARTICIPANT_TRUST_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANT_TRUST_COMPANY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_PHYSICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_PHYSICAL);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_DEPOSITORY_TRUST_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORY_TRUST_COMPANY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_LOCAL_MARKET_SETTLE_LOCATION);
  return _val;
}


SWIGINTERN VALUE
_wrap_SettlLocation_FEDERAL_BOOK_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_FEDERAL_BOOK_ENTRY);
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL_EXCLUDING_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_PUBLIC_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLIC_COMPANY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_INDIVIDUAL_TRUSTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_TRUSTEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_INDIVIDUAL_INVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_INVESTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_COMPANY_TRUSTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANY_TRUSTEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_PRIVATE_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATE_COMPANY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_NETWORKING_SUB_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_NETWORKING_SUB_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_PENSION_PLAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSION_PLAN));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_TRUSTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_TRUSTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_FIDUCIARIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIDUCIARIES));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_NON_PROFIT_ORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_NON_PROFIT_ORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_CORPORATE_BODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPORATE_BODY));
  return _val;
}


SWIGINTERN VALUE
_wrap_OwnerType_NOMINEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_NOMINEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueResolution_END_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_END_SESSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueResolution_QUEUE_FLUSHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUE_FLUSHED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueResolution_OVERLAY_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAY_LAST));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplQueueResolution_NO_ACTION_TAKEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_NO_ACTION_TAKEN));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NO_ACKNOWLEDGEMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_RECEIVED_NOT_YET_PROCESSED));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecAckStatus_DONT_KNOW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_DONT_KNOW));
  return _val;
}


SWIGINTERN VALUE
_wrap_ExecAckStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetGrossInd_NET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_NET));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetGrossInd_GROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_GROSS));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlType_PARTIAL_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlType_PARTIAL_CANCEL));
  return _val;
}


SWIGINTERN VALUE
_wrap_CxlType_FULL_REMAINING_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlType_FULL_REMAINING_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_DeskTypeSource_NASD_OATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeskTypeSource_NASD_OATS));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionRoundDirection_MORE_AGGRESSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionRoundDirection_MORE_PASSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidDescriptorType_COUNTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_COUNTRY));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidDescriptorType_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_INDEX));
  return _val;
}


SWIGINTERN VALUE
_wrap_BidDescriptorType_SECTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_SECTOR));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetworkStatusResponseType_INCREMENTAL_UPDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTAL_UPDATE));
  return _val;
}


SWIGINTERN VALUE
_wrap_NetworkStatusResponseType_FULL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_FULL));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteType_INDICATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_INDICATIVE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteType_RESTRICTED_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTED_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteType_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_QuoteType_COUNTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_COUNTER));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_MARKET_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_MARKET_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_VWAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_MIDPOINT_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_DISPLAYED_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_PRIMARY_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_PRIMARY_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_AVERAGE_PRICE_GUARANTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_AVERAGE_PRICE_GUARANTEE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_LAST_TRADE_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUY_SIDE_IS_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELL_SIDE_IS_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossPrioritization_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_NONE));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossPrioritization_SELLSIDE_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELLSIDE_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
_wrap_CrossPrioritization_BUYSIDE_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUYSIDE_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIOthSvc_AUTEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_AUTEX));
  return _val;
}


SWIGINTERN VALUE
_wrap_IOIOthSvc_BRIDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_BRIDGE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDENTRYTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_INSUFFICIENT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_INSUFFICIENT_BANDWIDTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_BANDWIDTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_SCOPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SCOPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_DUPLICATE_MDREQID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPLICATE_MDREQID));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDUPDATETYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MARKETDEPTH));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_INSUFFICIENT_PERMISSIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_PERMISSIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ApplReqType_CANCEL_RETRANSMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_AggressorIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
_wrap_AggressorIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNKNOWN_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_SECURITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_INVALID_PRICE_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_INVALID_PRICE_INCREMENT));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNKNOWN_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_MESSAGE_TYPE));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_NOT_AUTHORIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOT_AUTHORIZED));
  return _val;
}


SWIGINTERN VALUE
_wrap_BusinessRejectReason_UNKOWN_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKOWN_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_BookingType_REGULAR_BOOKING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULAR_BOOKING));
  return _val;
}


SWIGINTERN VALUE
_wrap_BookingType_CFD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_CFD));
  return _val;
}


SWIGINTERN VALUE
_wrap_BookingType_TOTAL_RETURN_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_TOTAL_RETURN_SWAP));
  return _val;
}


swig_class SwigClassSessionID;

SWIGINTERN VALUE
_wrap_new_SessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SessionID";
  FIX::SessionID *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SessionID *)new FIX::SessionID();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SessionID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionID";
  FIX::SessionID *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (FIX::SessionID *)new FIX::SessionID((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[3], 0 );
      rb_str_append( argv[3], rb_str_new2(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 self;
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 Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SessionID_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SessionID_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SessionID);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SessionID__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionID";
  FIX::SessionID *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionID", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionID", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (FIX::SessionID *)new FIX::SessionID((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SessionID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SessionID__SWIG_0(nargs, args, self);
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SessionID__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SessionID__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SessionID.new", 
    "    SessionID.new()\n"
    "    SessionID.new(std::string const &beginString, std::string const &senderCompID, std::string const &targetCompID, std::string const &sessionQualifier)\n"
    "    SessionID.new(std::string const &beginString, std::string const &senderCompID, std::string const &targetCompID)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_getBeginString(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::BeginString *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","getBeginString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (FIX::BeginString *) &((FIX::SessionID const *)arg1)->getBeginString();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_getSenderCompID(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::SenderCompID *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","getSenderCompID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (FIX::SenderCompID *) &((FIX::SessionID const *)arg1)->getSenderCompID();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_getTargetCompID(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::TargetCompID *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","getTargetCompID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (FIX::TargetCompID *) &((FIX::SessionID const *)arg1)->getTargetCompID();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_getSessionQualifier(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","getSessionQualifier", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (std::string *) &((FIX::SessionID const *)arg1)->getSessionQualifier();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_isFIXT(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","isFIXT", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (bool)((FIX::SessionID const *)arg1)->isFIXT();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_toString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = ((FIX::SessionID const *)arg1)->toString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_toStringFrozen(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","toStringFrozen", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (std::string *) &((FIX::SessionID const *)arg1)->toStringFrozen();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_fromString(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID *","fromString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","fromString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","fromString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->fromString((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_toString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  result = (std::string *) &((FIX::SessionID const *)arg1)->toString(*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SessionID_toString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SessionID_toString__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionID_toString__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SessionID.toString", 
    "    std::string & SessionID.toString()\n"
    "    std::string & SessionID.toString(std::string &str)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::SessionID.~

  call-seq:
    ~ -> SessionID

Invert operator.
*/
SWIGINTERN VALUE
_wrap_SessionID___invert__(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::SessionID result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const *","operator ~", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = ((FIX::SessionID const *)arg1)->operator ~();
  vresult = SWIG_NewPointerObj((new FIX::SessionID(static_cast< const FIX::SessionID& >(result))), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID___str__(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID *","__str__", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = FIX_SessionID___str__(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionID(FIX::SessionID *arg1) {
    delete arg1;
}


/*
  Document-method: Quickfix::FIX.<

  call-seq:
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool
    <(lhs, rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap___lt____SWIG_4(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::operator <", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::operator <", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::operator <", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::operator <", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (bool)FIX::operator <((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___lt__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__lt__", 
    "    bool __lt__(FIX::StringField const &lhs, char const *rhs)\n"
    "    bool __lt__(char const *lhs, FIX::StringField const &rhs)\n"
    "    bool __lt__(FIX::StringField const &lhs, std::string const &rhs)\n"
    "    bool __lt__(std::string const &lhs, FIX::StringField const &rhs)\n"
    "    bool __lt__(FIX::SessionID const &lhs, FIX::SessionID const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.==

  call-seq:
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool
    ==(lhs, rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap___eq____SWIG_4(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::operator ==", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::operator ==", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::operator ==", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::operator ==", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (bool)FIX::operator ==((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___eq__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__eq__", 
    "    bool __eq__(FIX::StringField const &lhs, char const *rhs)\n"
    "    bool __eq__(char const *lhs, FIX::StringField const &rhs)\n"
    "    bool __eq__(FIX::StringField const &lhs, std::string const &rhs)\n"
    "    bool __eq__(std::string const &lhs, FIX::StringField const &rhs)\n"
    "    bool __eq__(FIX::SessionID const &lhs, FIX::SessionID const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.<<

  call-seq:
    <<(stream, field) -> std::ostream
    <<(stream, message) -> std::ostream
    <<(stream, sessionID) -> std::ostream
    <<(?, ?) -> std::ostream

Left shifting or appending operator.
*/
SWIGINTERN VALUE
_wrap___lshift____SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ostream &","FIX::operator <<", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","FIX::operator <<", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::operator <<", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::operator <<", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.>>

  call-seq:
    >>(stream, sessionID) -> std::istream
    >>(?, ?) -> std::istream

Right shifting operator or extracting operator.
*/
SWIGINTERN VALUE
_wrap___rshift____SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::istream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::istream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::istream &","FIX::operator >>", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::istream &","FIX::operator >>", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID &","FIX::operator >>", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID &","FIX::operator >>", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (std::istream *) &FIX::operator >>(*arg1,*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDictionary;

SWIGINTERN VALUE
_wrap_new_Dictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::Dictionary";
  FIX::Dictionary *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Dictionary", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Dictionary", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::Dictionary *)new FIX::Dictionary((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Dictionary_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Dictionary_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Dictionary);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Dictionary__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::Dictionary";
  FIX::Dictionary *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::Dictionary *)new FIX::Dictionary();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Dictionary(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Dictionary__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Dictionary__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Dictionary.new", 
    "    Dictionary.new(std::string const &name)\n"
    "    Dictionary.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_Dictionary(FIX::Dictionary *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Dictionary_getName(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  result = ((FIX::Dictionary const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Quickfix::Dictionary.size

  call-seq:
    size -> int

Size or Length of the Dictionary.
*/
SWIGINTERN VALUE
_wrap_Dictionary_size(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  result = (int)((FIX::Dictionary const *)arg1)->size();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","getString", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  try {
    result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2,arg3);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldConvertError, SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldConvertError, SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Dictionary_getString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Dictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Dictionary_getString__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Dictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Dictionary_getString__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Dictionary.getString", 
    "    std::string Dictionary.getString(std::string const &, bool capitalize)\n"
    "    std::string Dictionary.getString(std::string const &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getLong(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getLong", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getLong", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getLong", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    result = (long)((FIX::Dictionary const *)arg1)->getLong((std::string const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldConvertError, SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_long(static_cast< long >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getDouble(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getDouble", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getDouble", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getDouble", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    result = (double)((FIX::Dictionary const *)arg1)->getDouble((std::string const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldConvertError, SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_double(static_cast< double >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getBool(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getBool", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getBool", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getBool", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    result = (bool)((FIX::Dictionary const *)arg1)->getBool((std::string const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldConvertError, SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getDay(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","getDay", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getDay", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getDay", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    result = (int)((FIX::Dictionary const *)arg1)->getDay((std::string const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldConvertError, SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_setString(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary *","setString", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","setString", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setString", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setString((std::string const &)*arg2,(std::string const &)*arg3);
  vresult = rb_ary_new();
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_setLong(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  long val3 ;
  int ecode3 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary *","setLong", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setLong", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setLong", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","setLong", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->setLong((std::string const &)*arg2,arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_setDouble(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary *","setDouble", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setDouble", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setDouble", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","setDouble", 3, argv[1] ));
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setDouble((std::string const &)*arg2,arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_setBool(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary *","setBool", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setBool", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setBool", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setBool", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setBool((std::string const &)*arg2,arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_setDay(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary *","setDay", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setDay", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setDay", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","setDay", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setDay((std::string const &)*arg2,arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_has(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","has", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","has", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","has", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((FIX::Dictionary const *)arg1)->has((std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_merge(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  FIX::Dictionary *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Dictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Dictionary const &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Dictionary const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Dictionary * >(argp2);
  (arg1)->merge((FIX::Dictionary const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_begin(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Dictionary::iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  result = ((FIX::Dictionary const *)arg1)->begin();
  vresult = SWIG_NewPointerObj((new FIX::Dictionary::iterator(static_cast< const FIX::Dictionary::iterator& >(result))), SWIGTYPE_p_FIX__Dictionary__Data__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_end(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Dictionary::iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Dictionary const *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  result = ((FIX::Dictionary const *)arg1)->end();
  vresult = SWIG_NewPointerObj((new FIX::Dictionary::iterator(static_cast< const FIX::Dictionary::iterator& >(result))), SWIGTYPE_p_FIX__Dictionary__Data__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BEGINSTRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BEGINSTRING);
  return _val;
}


SWIGINTERN VALUE
_wrap_SENDERCOMPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SENDERCOMPID);
  return _val;
}


SWIGINTERN VALUE
_wrap_TARGETCOMPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TARGETCOMPID);
  return _val;
}


SWIGINTERN VALUE
_wrap_SESSION_QUALIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SESSION_QUALIFIER);
  return _val;
}


SWIGINTERN VALUE
_wrap_DEFAULT_APPLVERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DEFAULT_APPLVERID);
  return _val;
}


SWIGINTERN VALUE
_wrap_CONNECTION_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CONNECTION_TYPE);
  return _val;
}


SWIGINTERN VALUE
_wrap_USE_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::USE_DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SEND_RESETSEQNUMFLAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SEND_RESETSEQNUMFLAG);
  return _val;
}


SWIGINTERN VALUE
_wrap_SEND_REDUNDANT_RESENDREQUESTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SEND_REDUNDANT_RESENDREQUESTS);
  return _val;
}


SWIGINTERN VALUE
_wrap_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
_wrap_TRANSPORT_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TRANSPORT_DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
_wrap_APP_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::APP_DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
_wrap_USE_LOCAL_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::USE_LOCAL_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_START_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::START_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_END_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::END_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_START_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::START_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_END_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::END_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_LOGON_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGON_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_LOGOUT_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGOUT_TIME);
  return _val;
}


SWIGINTERN VALUE
_wrap_LOGON_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGON_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_LOGOUT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGOUT_DAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_CHECK_COMPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CHECK_COMPID);
  return _val;
}


SWIGINTERN VALUE
_wrap_CHECK_LATENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CHECK_LATENCY);
  return _val;
}


SWIGINTERN VALUE
_wrap_MAX_LATENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MAX_LATENCY);
  return _val;
}


SWIGINTERN VALUE
_wrap_HEARTBTINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::HEARTBTINT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_ACCEPT_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_ACCEPT_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_REUSE_ADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_REUSE_ADDRESS);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_CONNECT_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_HOST);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_CONNECT_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_NODELAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_NODELAY);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_SEND_BUFFER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_SEND_BUFFER_SIZE);
  return _val;
}


SWIGINTERN VALUE
_wrap_SOCKET_RECEIVE_BUFFER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_RECEIVE_BUFFER_SIZE);
  return _val;
}


SWIGINTERN VALUE
_wrap_RECONNECT_INTERVAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RECONNECT_INTERVAL);
  return _val;
}


SWIGINTERN VALUE
_wrap_VALIDATE_LENGTH_AND_CHECKSUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_LENGTH_AND_CHECKSUM);
  return _val;
}


SWIGINTERN VALUE
_wrap_VALIDATE_FIELDS_OUT_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_OUT_OF_ORDER);
  return _val;
}


SWIGINTERN VALUE
_wrap_VALIDATE_FIELDS_HAVE_VALUES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_HAVE_VALUES);
  return _val;
}


SWIGINTERN VALUE
_wrap_VALIDATE_USER_DEFINED_FIELDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_USER_DEFINED_FIELDS);
  return _val;
}


SWIGINTERN VALUE
_wrap_LOGON_TIMEOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGON_TIMEOUT);
  return _val;
}


SWIGINTERN VALUE
_wrap_LOGOUT_TIMEOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGOUT_TIMEOUT);
  return _val;
}


SWIGINTERN VALUE
_wrap_FILE_STORE_PATH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FILE_STORE_PATH);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_STORE_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_STORE_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_DATABASE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_STORE_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_USER);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_STORE_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_STORE_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_HOST);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_STORE_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_STORE_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_STORE_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_DATABASE);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_STORE_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USER);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_STORE_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_STORE_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_HOST);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_STORE_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_STORE_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_STORE_USER);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_STORE_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_STORE_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_STORE_CONNECTION_STRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_STORE_CONNECTION_STRING);
  return _val;
}


SWIGINTERN VALUE
_wrap_FILE_LOG_PATH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FILE_LOG_PATH);
  return _val;
}


SWIGINTERN VALUE
_wrap_FILE_LOG_BACKUP_PATH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FILE_LOG_BACKUP_PATH);
  return _val;
}


SWIGINTERN VALUE
_wrap_SCREEN_LOG_SHOW_INCOMING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_INCOMING);
  return _val;
}


SWIGINTERN VALUE
_wrap_SCREEN_LOG_SHOW_OUTGOING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_OUTGOING);
  return _val;
}


SWIGINTERN VALUE
_wrap_SCREEN_LOG_SHOW_EVENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_EVENTS);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_DATABASE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_USER);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_HOST);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_INCOMING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_INCOMING_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_OUTGOING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_OUTGOING_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_LOG_EVENT_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_EVENT_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_DATABASE);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USER);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_HOST);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_INCOMING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_INCOMING_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_OUTGOING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_OUTGOING_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_POSTGRESQL_LOG_EVENT_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_EVENT_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_LOG_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_USER);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_LOG_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_LOG_CONNECTION_STRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_CONNECTION_STRING);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_LOG_INCOMING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_INCOMING_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_LOG_OUTGOING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_OUTGOING_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_ODBC_LOG_EVENT_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_EVENT_TABLE);
  return _val;
}


SWIGINTERN VALUE
_wrap_RESET_ON_LOGON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RESET_ON_LOGON);
  return _val;
}


SWIGINTERN VALUE
_wrap_RESET_ON_LOGOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RESET_ON_LOGOUT);
  return _val;
}


SWIGINTERN VALUE
_wrap_RESET_ON_DISCONNECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RESET_ON_DISCONNECT);
  return _val;
}


SWIGINTERN VALUE
_wrap_REFRESH_ON_LOGON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::REFRESH_ON_LOGON);
  return _val;
}


SWIGINTERN VALUE
_wrap_MILLISECONDS_IN_TIMESTAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MILLISECONDS_IN_TIMESTAMP);
  return _val;
}


SWIGINTERN VALUE
_wrap_HTTP_ACCEPT_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::HTTP_ACCEPT_PORT);
  return _val;
}


SWIGINTERN VALUE
_wrap_PERSIST_MESSAGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PERSIST_MESSAGES);
  return _val;
}


swig_class SwigClassSessionSettings;

SWIGINTERN VALUE
_wrap_new_SessionSettings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::SessionSettings";
  FIX::SessionSettings *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::SessionSettings *)new FIX::SessionSettings();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SessionSettings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionSettings";
  FIX::SessionSettings *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::istream &","FIX::SessionSettings", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::istream &","FIX::SessionSettings", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  try {
    result = (FIX::SessionSettings *)new FIX::SessionSettings(*arg1);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SessionSettings_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SessionSettings_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SessionSettings);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SessionSettings__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionSettings";
  FIX::SessionSettings *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::SessionSettings", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::SessionSettings", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  try {
    result = (FIX::SessionSettings *)new FIX::SessionSettings((std::string const &)*arg1);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SessionSettings(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SessionSettings__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionSettings__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionSettings__SWIG_2(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SessionSettings.new", 
    "    SessionSettings.new()\n"
    "    SessionSettings.new(std::istream &stream)\n"
    "    SessionSettings.new(std::string const &file)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_has(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const *","has", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","has", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","has", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (bool)((FIX::SessionSettings const *)arg1)->has((FIX::SessionID const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_get__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Dictionary *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","get", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","get", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  try {
    result = (FIX::Dictionary *) &((FIX::SessionSettings const *)arg1)->get((FIX::SessionID const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_set__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::Dictionary arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","set", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","set", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__Dictionary,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::Dictionary","set", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Dictionary","set", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< FIX::Dictionary * >(argp3));
    }
  }
  try {
    (arg1)->set((FIX::SessionID const &)*arg2,arg3);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_get__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Dictionary *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  result = (FIX::Dictionary *) &((FIX::SessionSettings const *)arg1)->get();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SessionSettings_get(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SessionSettings_get__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionSettings_get__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SessionSettings.get", 
    "    FIX::Dictionary const & SessionSettings.get(FIX::SessionID const &)\n"
    "    FIX::Dictionary const & SessionSettings.get()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_set__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::Dictionary *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Dictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Dictionary const &","set", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Dictionary const &","set", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Dictionary * >(argp2);
  try {
    (arg1)->set((FIX::Dictionary const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SessionSettings_set(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Dictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionSettings_set__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Dictionary, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SessionSettings_set__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SessionSettings.set", 
    "    void SessionSettings.set(FIX::SessionID const &, FIX::Dictionary)\n"
    "    void SessionSettings.set(FIX::Dictionary const &defaults)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::SessionSettings.size

  call-seq:
    size -> int

Size or Length of the SessionSettings.
*/
SWIGINTERN VALUE
_wrap_SessionSettings_size(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  result = (int)((FIX::SessionSettings const *)arg1)->size();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_getSessions(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::set< FIX::SessionID > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const *","getSessions", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  result = ((FIX::SessionSettings const *)arg1)->getSessions();
  vresult = SWIG_NewPointerObj((new std::set< FIX::SessionID >(static_cast< const std::set< FIX::SessionID >& >(result))), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionSettings(FIX::SessionSettings *arg1) {
    delete arg1;
}


/*
  Document-method: Quickfix::FIX.>>

  call-seq:
    >>(stream, sessionID) -> std::istream
    >>(?, ?) -> std::istream

Right shifting operator or extracting operator.
*/
SWIGINTERN VALUE
_wrap___rshift____SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::istream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::istream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::istream &","FIX::operator >>", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::istream &","FIX::operator >>", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionSettings &","FIX::operator >>", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings &","FIX::operator >>", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  try {
    result = (std::istream *) &FIX::operator >>(*arg1,*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___rshift__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___rshift____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___rshift____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__rshift__", 
    "    std::istream & __rshift__(std::istream &stream, FIX::SessionID &sessionID)\n"
    "    std::istream & __rshift__(std::istream &, FIX::SessionSettings &)\n");
  
  return Qnil;
}



/*
  Document-method: Quickfix::FIX.<<

  call-seq:
    <<(stream, field) -> std::ostream
    <<(stream, message) -> std::ostream
    <<(stream, sessionID) -> std::ostream
    <<(?, ?) -> std::ostream

Left shifting or appending operator.
*/
SWIGINTERN VALUE
_wrap___lshift____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ostream &","FIX::operator <<", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","FIX::operator <<", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::operator <<", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::operator <<", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::SessionSettings const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___lshift__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__lshift__", 
    "    std::ostream & __lshift__(std::ostream &stream, FIX::FieldBase const &field)\n"
    "    std::ostream & __lshift__(std::ostream &stream, FIX::Message const &message)\n"
    "    std::ostream & __lshift__(std::ostream &stream, FIX::SessionID const &sessionID)\n"
    "    std::ostream & __lshift__(std::ostream &, FIX::SessionSettings const &)\n");
  
  return Qnil;
}


swig_class SwigClassSession;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Session_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Session_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Session);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Session(int argc, VALUE *argv, VALUE self) {
  Application *arg1 = 0 ;
  MessageStoreFactory *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  DataDictionaryProvider *arg4 = 0 ;
  TimeRange *arg5 = 0 ;
  int arg6 ;
  LogFactory *arg7 = (LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Session";
  FIX::Session *result = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Application &","FIX::Session", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Application &","FIX::Session", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "MessageStoreFactory &","FIX::Session", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "MessageStoreFactory &","FIX::Session", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_DataDictionaryProvider,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "DataDictionaryProvider const &","FIX::Session", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "DataDictionaryProvider const &","FIX::Session", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< DataDictionaryProvider * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_TimeRange,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "TimeRange const &","FIX::Session", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TimeRange const &","FIX::Session", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< TimeRange * >(argp5);
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","FIX::Session", 6, argv[5] ));
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "LogFactory *","FIX::Session", 7, argv[6] )); 
  }
  arg7 = reinterpret_cast< LogFactory * >(argp7);
  result = (FIX::Session *)new FIX::Session(*arg1,*arg2,(FIX::SessionID const &)*arg3,(DataDictionaryProvider const &)*arg4,(TimeRange const &)*arg5,arg6,arg7);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_Session(FIX::Session *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Session_logon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","logon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  (arg1)->logon();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_logout__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","logout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","logout", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","logout", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->logout((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_logout__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","logout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  (arg1)->logout();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Session_logout(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_logout__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_logout__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Session.logout", 
    "    void Session.logout(std::string const &reason)\n"
    "    void Session.logout()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isEnabled(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","isEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->isEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sentLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","sentLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->sentLogon();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sentLogout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","sentLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->sentLogout();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_receivedLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","receivedLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->receivedLogon();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isLoggedOn(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","isLoggedOn", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->isLoggedOn();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_reset(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  try {
    (arg1)->reset();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_refresh(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","refresh", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  try {
    (arg1)->refresh();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextSenderMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextSenderMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextTargetMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextTargetMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getSessionID(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::SessionID *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session const *","getSessionID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (FIX::SessionID *) &((FIX::Session const *)arg1)->getSessionID();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setDataDictionaryProvider(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  DataDictionaryProvider *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setDataDictionaryProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_DataDictionaryProvider,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "DataDictionaryProvider const &","setDataDictionaryProvider", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "DataDictionaryProvider const &","setDataDictionaryProvider", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< DataDictionaryProvider * >(argp2);
  (arg1)->setDataDictionaryProvider((DataDictionaryProvider const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getDataDictionaryProvider(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DataDictionaryProvider *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session const *","getDataDictionaryProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (DataDictionaryProvider *) &((FIX::Session const *)arg1)->getDataDictionaryProvider();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DataDictionaryProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session::sendToTarget", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session::sendToTarget", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SessionID const &)*arg2);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  FIX::SenderCompID *arg2 = 0 ;
  FIX::TargetCompID *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SenderCompID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SenderCompID const &","FIX::Session::sendToTarget", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SenderCompID const &","FIX::Session::sendToTarget", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SenderCompID * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__TargetCompID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::TargetCompID const &","FIX::Session::sendToTarget", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TargetCompID const &","FIX::Session::sendToTarget", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::TargetCompID * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3,(std::string const &)*arg4);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[3], 0 );
      rb_str_append( argv[3], rb_str_new2(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_4(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  FIX::SenderCompID *arg2 = 0 ;
  FIX::TargetCompID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SenderCompID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SenderCompID const &","FIX::Session::sendToTarget", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SenderCompID const &","FIX::Session::sendToTarget", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SenderCompID * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__TargetCompID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::TargetCompID const &","FIX::Session::sendToTarget", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TargetCompID const &","FIX::Session::sendToTarget", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::TargetCompID * >(argp3);
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_5(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[3], 0 );
      rb_str_append( argv[3], rb_str_new2(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_sendToTarget__SWIG_6(int argc, VALUE *argv, VALUE self) {
  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;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","FIX::Session::sendToTarget", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::sendToTarget", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::sendToTarget", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  try {
    result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  }
  catch(FIX::SessionNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__SessionNotFound, SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Session_sendToTarget(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_sendToTarget__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_sendToTarget__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_sendToTarget__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SenderCompID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__TargetCompID, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_sendToTarget__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_sendToTarget__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SenderCompID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__TargetCompID, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Session_sendToTarget__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Session_sendToTarget__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Session.sendToTarget", 
    "    bool Session.sendToTarget(FIX::Message &message, std::string const &qualifier)\n"
    "    bool Session.sendToTarget(FIX::Message &message)\n"
    "    bool Session.sendToTarget(FIX::Message &message, FIX::SessionID const &sessionID)\n"
    "    bool Session.sendToTarget(FIX::Message &, FIX::SenderCompID const &senderCompID, FIX::TargetCompID const &targetCompID, std::string const &qualifier)\n"
    "    bool Session.sendToTarget(FIX::Message &, FIX::SenderCompID const &senderCompID, FIX::TargetCompID const &targetCompID)\n"
    "    bool Session.sendToTarget(FIX::Message &message, std::string const &senderCompID, std::string const &targetCompID, std::string const &qualifier)\n"
    "    bool Session.sendToTarget(FIX::Message &message, std::string const &senderCompID, std::string const &targetCompID)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getSessions(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< std::set< FIX::SessionID > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = FIX::Session::getSessions();
  vresult = SWIG_NewPointerObj((new std::set< FIX::SessionID >(static_cast< const std::set< FIX::SessionID >& >(result))), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_doesSessionExist(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session::doesSessionExist", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session::doesSessionExist", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (bool)FIX::Session::doesSessionExist((FIX::SessionID const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_lookupSession__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session::lookupSession", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session::lookupSession", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (FIX::Session *)FIX::Session::lookupSession((FIX::SessionID const &)*arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_lookupSession__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::lookupSession", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::lookupSession", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::Session::lookupSession", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (FIX::Session *)FIX::Session::lookupSession((std::string const &)*arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_lookupSession__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::Session::lookupSession", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::Session::lookupSession", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::Session *)FIX::Session::lookupSession((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Session_lookupSession(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_lookupSession__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_lookupSession__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Session_lookupSession__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Session.lookupSession", 
    "    FIX::Session * Session.lookupSession(FIX::SessionID const &)\n"
    "    FIX::Session * Session.lookupSession(std::string const &, bool reverse)\n"
    "    FIX::Session * Session.lookupSession(std::string const &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isSessionRegistered(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session::isSessionRegistered", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session::isSessionRegistered", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (bool)FIX::Session::isSessionRegistered((FIX::SessionID const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_registerSession(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session::registerSession", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session::registerSession", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  result = (FIX::Session *)FIX::Session::registerSession((FIX::SessionID const &)*arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_unregisterSession(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::Session::unregisterSession", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::Session::unregisterSession", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  FIX::Session::unregisterSession((FIX::SessionID const &)*arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_numSessions(int argc, VALUE *argv, VALUE self) {
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (int)FIX::Session::numSessions();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isSessionTime(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","isSessionTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp const &","isSessionTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","isSessionTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  result = (bool)(arg1)->isSessionTime((UtcTimeStamp const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isLogonTime(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","isLogonTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp const &","isLogonTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","isLogonTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  result = (bool)(arg1)->isLogonTime((UtcTimeStamp const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isInitiator(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","isInitiator", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->isInitiator();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isAcceptor(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","isAcceptor", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->isAcceptor();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getLogonTime(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TimeRange *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getLogonTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (TimeRange *) &(arg1)->getLogonTime();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeRange, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setLogonTime(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  TimeRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setLogonTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_TimeRange,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TimeRange const &","setLogonTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TimeRange const &","setLogonTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< TimeRange * >(argp2);
  (arg1)->setLogonTime((TimeRange const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getSenderDefaultApplVerID(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getSenderDefaultApplVerID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (std::string *) &(arg1)->getSenderDefaultApplVerID();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setSenderDefaultApplVerID(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setSenderDefaultApplVerID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setSenderDefaultApplVerID", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setSenderDefaultApplVerID", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSenderDefaultApplVerID((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getTargetDefaultApplVerID(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getTargetDefaultApplVerID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (std::string *) &(arg1)->getTargetDefaultApplVerID();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setTargetDefaultApplVerID(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setTargetDefaultApplVerID", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setTargetDefaultApplVerID", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setTargetDefaultApplVerID", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setTargetDefaultApplVerID((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getSendRedundantResendRequests(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getSendRedundantResendRequests", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getSendRedundantResendRequests();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setSendRedundantResendRequests(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setSendRedundantResendRequests", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSendRedundantResendRequests", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSendRedundantResendRequests(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getCheckCompId(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getCheckCompId", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getCheckCompId();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setCheckCompId(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setCheckCompId", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCheckCompId", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCheckCompId(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getCheckLatency(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getCheckLatency", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getCheckLatency();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setCheckLatency(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setCheckLatency", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCheckLatency", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCheckLatency(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getMaxLatency(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getMaxLatency", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (int)(arg1)->getMaxLatency();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setMaxLatency(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setMaxLatency", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setMaxLatency", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setMaxLatency(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getLogonTimeout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getLogonTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (int)(arg1)->getLogonTimeout();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setLogonTimeout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setLogonTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setLogonTimeout", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setLogonTimeout(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getLogoutTimeout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getLogoutTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (int)(arg1)->getLogoutTimeout();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setLogoutTimeout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setLogoutTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setLogoutTimeout", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setLogoutTimeout(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getResetOnLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getResetOnLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getResetOnLogon();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setResetOnLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setResetOnLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setResetOnLogon", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setResetOnLogon(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getResetOnLogout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getResetOnLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getResetOnLogout();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setResetOnLogout(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setResetOnLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setResetOnLogout", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setResetOnLogout(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getResetOnDisconnect(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getResetOnDisconnect", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getResetOnDisconnect();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setResetOnDisconnect(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setResetOnDisconnect", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setResetOnDisconnect", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setResetOnDisconnect(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getRefreshOnLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getRefreshOnLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getRefreshOnLogon();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setRefreshOnLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setRefreshOnLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setRefreshOnLogon", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setRefreshOnLogon(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getMillisecondsInTimeStamp(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getMillisecondsInTimeStamp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getMillisecondsInTimeStamp();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setMillisecondsInTimeStamp(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setMillisecondsInTimeStamp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setMillisecondsInTimeStamp", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setMillisecondsInTimeStamp(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getPersistMessages(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getPersistMessages", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getPersistMessages();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setPersistMessages(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setPersistMessages", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPersistMessages", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPersistMessages(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getValidateLengthAndChecksum(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getValidateLengthAndChecksum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (bool)(arg1)->getValidateLengthAndChecksum();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setValidateLengthAndChecksum(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setValidateLengthAndChecksum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setValidateLengthAndChecksum", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setValidateLengthAndChecksum(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_setResponder(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  Responder *arg2 = (Responder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","setResponder", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Responder, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Responder *","setResponder", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Responder * >(argp2);
  (arg1)->setResponder(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_send(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","send", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","send", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","send", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  result = (bool)(arg1)->send(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  (arg1)->next();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp const &","next", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","next", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  (arg1)->next((UtcTimeStamp const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_next__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  UtcTimeStamp *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","next", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","next", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "UtcTimeStamp const &","next", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","next", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","next", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->next((std::string const &)*arg2,(UtcTimeStamp const &)*arg3,arg4);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_next__SWIG_3(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  UtcTimeStamp *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","next", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","next", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "UtcTimeStamp const &","next", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","next", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  (arg1)->next((std::string const &)*arg2,(UtcTimeStamp const &)*arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_next__SWIG_4(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  UtcTimeStamp *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","next", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","next", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "UtcTimeStamp const &","next", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","next", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","next", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->next((FIX::Message const &)*arg2,(UtcTimeStamp const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_next__SWIG_5(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  UtcTimeStamp *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","next", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","next", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "UtcTimeStamp const &","next", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","next", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  (arg1)->next((FIX::Message const &)*arg2,(UtcTimeStamp const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Session_next(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_next__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_next__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_next__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_next__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Session_next__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Session_next__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Session.next", 
    "    void Session.next()\n"
    "    void Session.next(UtcTimeStamp const &timeStamp)\n"
    "    void Session.next(std::string const &, UtcTimeStamp const &timeStamp, bool queued)\n"
    "    void Session.next(std::string const &, UtcTimeStamp const &timeStamp)\n"
    "    void Session.next(FIX::Message const &, UtcTimeStamp const &timeStamp, bool queued)\n"
    "    void Session.next(FIX::Message const &, UtcTimeStamp const &timeStamp)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_disconnect(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","disconnect", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  (arg1)->disconnect();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getExpectedSenderNum(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getExpectedSenderNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (long)(arg1)->getExpectedSenderNum();
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getExpectedTargetNum(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getExpectedTargetNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (long)(arg1)->getExpectedTargetNum();
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getLog(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getLog", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (Log *)(arg1)->getLog();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_getStore(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MessageStore *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Session *","getStore", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  result = (MessageStore *)(arg1)->getStore();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MessageStore, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassLogFactory;

SWIGINTERN void
free_FIX_LogFactory(FIX::LogFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LogFactory_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LogFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  result = (FIX::Log *)(arg1)->create();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogFactory_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LogFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogFactory_create(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LogFactory_create__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LogFactory_create__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LogFactory.create", 
    "    FIX::Log * LogFactory.create()\n"
    "    FIX::Log * LogFactory.create(FIX::SessionID const &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogFactory_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::LogFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Log *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassScreenLogFactory;

SWIGINTERN VALUE
_wrap_new_ScreenLogFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLogFactory";
  FIX::ScreenLogFactory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::ScreenLogFactory", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::ScreenLogFactory", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  result = (FIX::ScreenLogFactory *)new FIX::ScreenLogFactory((FIX::SessionSettings const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ScreenLogFactory_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ScreenLogFactory_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ScreenLogFactory);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ScreenLogFactory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLogFactory";
  FIX::ScreenLogFactory *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ScreenLogFactory", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ScreenLogFactory", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FIX::ScreenLogFactory", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (FIX::ScreenLogFactory *)new FIX::ScreenLogFactory(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ScreenLogFactory(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScreenLogFactory__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ScreenLogFactory__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ScreenLogFactory.new", 
    "    ScreenLogFactory.new(FIX::SessionSettings const &settings)\n"
    "    ScreenLogFactory.new(bool incoming, bool outgoing, bool event)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLogFactory_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLogFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  result = (FIX::Log *)(arg1)->create();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLogFactory_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLogFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ScreenLogFactory_create(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__ScreenLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ScreenLogFactory_create__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__ScreenLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ScreenLogFactory_create__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ScreenLogFactory.create", 
    "    FIX::Log * ScreenLogFactory.create()\n"
    "    FIX::Log * ScreenLogFactory.create(FIX::SessionID const &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLogFactory_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLogFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Log *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_ScreenLogFactory(FIX::ScreenLogFactory *arg1) {
    delete arg1;
}

swig_class SwigClassLog;

SWIGINTERN void
free_FIX_Log(FIX::Log *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Log_clear(int argc, VALUE *argv, VALUE self) {
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Log *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_backup(int argc, VALUE *argv, VALUE self) {
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Log *","backup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  (arg1)->backup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_onIncoming(int argc, VALUE *argv, VALUE self) {
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Log *","onIncoming", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onIncoming", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onIncoming", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onIncoming((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_onOutgoing(int argc, VALUE *argv, VALUE self) {
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Log *","onOutgoing", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onOutgoing", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onOutgoing", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onOutgoing((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_onEvent(int argc, VALUE *argv, VALUE self) {
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Log *","onEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onEvent((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassNullLog;

SWIGINTERN VALUE
_wrap_NullLog_clear(int argc, VALUE *argv, VALUE self) {
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NullLog *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NullLog_backup(int argc, VALUE *argv, VALUE self) {
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NullLog *","backup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  (arg1)->backup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NullLog_onIncoming(int argc, VALUE *argv, VALUE self) {
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NullLog *","onIncoming", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onIncoming", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onIncoming", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onIncoming((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NullLog_onOutgoing(int argc, VALUE *argv, VALUE self) {
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NullLog *","onOutgoing", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onOutgoing", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onOutgoing", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onOutgoing((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NullLog_onEvent(int argc, VALUE *argv, VALUE self) {
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::NullLog *","onEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onEvent((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NullLog_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NullLog_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NullLog);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NullLog(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NullLog";
  FIX::NullLog *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NullLog *)new FIX::NullLog();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_NullLog(FIX::NullLog *arg1) {
    delete arg1;
}

swig_class SwigClassScreenLog;

SWIGINTERN VALUE
_wrap_new_ScreenLog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLog";
  FIX::ScreenLog *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","FIX::ScreenLog", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ScreenLog", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FIX::ScreenLog", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (FIX::ScreenLog *)new FIX::ScreenLog(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ScreenLog_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ScreenLog_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__ScreenLog);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ScreenLog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLog";
  FIX::ScreenLog *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::ScreenLog", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::ScreenLog", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","FIX::ScreenLog", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FIX::ScreenLog", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","FIX::ScreenLog", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (FIX::ScreenLog *)new FIX::ScreenLog((FIX::SessionID const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ScreenLog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ScreenLog__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ScreenLog__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ScreenLog.new", 
    "    ScreenLog.new(bool incoming, bool outgoing, bool event)\n"
    "    ScreenLog.new(FIX::SessionID const &sessionID, bool incoming, bool outgoing, bool event)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_clear(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_backup(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog *","backup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  (arg1)->backup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_onIncoming(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog *","onIncoming", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onIncoming", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onIncoming", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onIncoming((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_onOutgoing(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog *","onOutgoing", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onOutgoing", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onOutgoing", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onOutgoing((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_onEvent(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog *","onEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onEvent((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_getMillisecondsInTimeStamp(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog const *","getMillisecondsInTimeStamp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  result = (bool)((FIX::ScreenLog const *)arg1)->getMillisecondsInTimeStamp();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLog_setMillisecondsInTimeStamp(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::ScreenLog *","setMillisecondsInTimeStamp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setMillisecondsInTimeStamp", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setMillisecondsInTimeStamp(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_ScreenLog(FIX::ScreenLog *arg1) {
    delete arg1;
}

swig_class SwigClassFileLogFactory;

SWIGINTERN VALUE
_wrap_new_FileLogFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileLogFactory";
  FIX::FileLogFactory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::FileLogFactory", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::FileLogFactory", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  result = (FIX::FileLogFactory *)new FIX::FileLogFactory((FIX::SessionSettings const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileLogFactory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileLogFactory";
  FIX::FileLogFactory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLogFactory", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLogFactory", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::FileLogFactory *)new FIX::FileLogFactory((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FileLogFactory_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FileLogFactory_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FileLogFactory);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FileLogFactory__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileLogFactory";
  FIX::FileLogFactory *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLogFactory", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLogFactory", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLogFactory", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLogFactory", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (FIX::FileLogFactory *)new FIX::FileLogFactory((std::string const &)*arg1,(std::string const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FileLogFactory(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLogFactory__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLogFactory__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileLogFactory__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "FileLogFactory.new", 
    "    FileLogFactory.new(FIX::SessionSettings const &settings)\n"
    "    FileLogFactory.new(std::string const &path)\n"
    "    FileLogFactory.new(std::string const &path, std::string const &backupPath)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLogFactory_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLogFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  result = (FIX::Log *)(arg1)->create();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLogFactory_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLogFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileLogFactory_create(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FileLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileLogFactory_create__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FileLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FileLogFactory_create__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FileLogFactory.create", 
    "    FIX::Log * FileLogFactory.create()\n"
    "    FIX::Log * FileLogFactory.create(FIX::SessionID const &)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLogFactory_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLogFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Log *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_FileLogFactory(FIX::FileLogFactory *arg1) {
    delete arg1;
}

swig_class SwigClassFileLog;

SWIGINTERN VALUE
_wrap_new_FileLog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileLog";
  FIX::FileLog *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLog", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLog", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileLog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileLog";
  FIX::FileLog *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLog", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLog", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::FileLog", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::FileLog", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1,(FIX::SessionID const &)*arg2);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FileLog_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FileLog_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FileLog);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FileLog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileLog";
  FIX::FileLog *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLog", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLog", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","FIX::FileLog", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileLog", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::FileLog", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::FileLog", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1,(std::string const &)*arg2,(FIX::SessionID const &)*arg3);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FileLog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLog__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileLog__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FileLog__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FileLog.new", 
    "    FileLog.new(std::string const &path)\n"
    "    FileLog.new(std::string const &path, FIX::SessionID const &sessionID)\n"
    "    FileLog.new(std::string const &path, std::string const &backupPath, FIX::SessionID const &sessionID)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_FileLog(FIX::FileLog *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FileLog_clear(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLog_backup(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog *","backup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  (arg1)->backup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLog_onIncoming(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog *","onIncoming", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onIncoming", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onIncoming", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onIncoming((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLog_onOutgoing(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog *","onOutgoing", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onOutgoing", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onOutgoing", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onOutgoing((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLog_onEvent(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog *","onEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","onEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","onEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->onEvent((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLog_getMillisecondsInTimeStamp(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog const *","getMillisecondsInTimeStamp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  result = (bool)((FIX::FileLog const *)arg1)->getMillisecondsInTimeStamp();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLog_setMillisecondsInTimeStamp(int argc, VALUE *argv, VALUE self) {
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileLog *","setMillisecondsInTimeStamp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setMillisecondsInTimeStamp", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setMillisecondsInTimeStamp(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMessageStoreFactory;

SWIGINTERN void
free_FIX_MessageStoreFactory(FIX::MessageStoreFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MessageStoreFactory_create(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::MessageStore *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreFactory_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStore *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMemoryStoreFactory;

SWIGINTERN VALUE
_wrap_MemoryStoreFactory_create(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::MessageStore *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStoreFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStoreFactory_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStoreFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStore *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MemoryStoreFactory_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MemoryStoreFactory_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MemoryStoreFactory);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MemoryStoreFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MemoryStoreFactory";
  FIX::MemoryStoreFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MemoryStoreFactory *)new FIX::MemoryStoreFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_MemoryStoreFactory(FIX::MemoryStoreFactory *arg1) {
    delete arg1;
}

swig_class SwigClassMessageStore;

SWIGINTERN void
free_FIX_MessageStore(FIX::MessageStore *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MessageStore_set(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","set", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","set", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  try {
    result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_get(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","get", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","get", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::string > &","get", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string > &","get", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  try {
    ((FIX::MessageStore const *)arg1)->get(arg2,arg3,*arg4);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_getNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore const *","getNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    result = (int)((FIX::MessageStore const *)arg1)->getNextSenderMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_getNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore const *","getNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    result = (int)((FIX::MessageStore const *)arg1)->getNextTargetMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_setNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","setNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextSenderMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextSenderMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_setNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","setNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextTargetMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextTargetMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_incrNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","incrNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    (arg1)->incrNextSenderMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_incrNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","incrNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    (arg1)->incrNextTargetMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_getCreationTime(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UtcTimeStamp result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore const *","getCreationTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    result = ((FIX::MessageStore const *)arg1)->getCreationTime();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_reset(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    (arg1)->reset();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStore_refresh(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","refresh", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    (arg1)->refresh();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMemoryStore;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MemoryStore_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MemoryStore_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MemoryStore);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MemoryStore(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::MemoryStore";
  FIX::MemoryStore *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::MemoryStore *)new FIX::MemoryStore();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_set(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","set", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","set", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  try {
    result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_get(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","get", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","get", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::string > &","get", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string > &","get", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  try {
    ((FIX::MemoryStore const *)arg1)->get(arg2,arg3,*arg4);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_getNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore const *","getNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    result = (int)((FIX::MemoryStore const *)arg1)->getNextSenderMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_getNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore const *","getNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    result = (int)((FIX::MemoryStore const *)arg1)->getNextTargetMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_setNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","setNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextSenderMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextSenderMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_setNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","setNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextTargetMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextTargetMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_incrNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","incrNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    (arg1)->incrNextSenderMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_incrNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","incrNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    (arg1)->incrNextTargetMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_setCreationTime(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","setCreationTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "UtcTimeStamp const &","setCreationTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "UtcTimeStamp const &","setCreationTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  try {
    (arg1)->setCreationTime((UtcTimeStamp const &)*arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_getCreationTime(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UtcTimeStamp result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore const *","getCreationTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    result = ((FIX::MemoryStore const *)arg1)->getCreationTime();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_reset(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    (arg1)->reset();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryStore_refresh(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MemoryStore *","refresh", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    (arg1)->refresh();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_MemoryStore(FIX::MemoryStore *arg1) {
    delete arg1;
}

swig_class SwigClassMessageStoreFactoryExceptionWrapper;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MessageStoreFactoryExceptionWrapper_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MessageStoreFactoryExceptionWrapper_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MessageStoreFactoryExceptionWrapper(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageStoreFactoryExceptionWrapper";
  FIX::MessageStoreFactoryExceptionWrapper *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory *","FIX::MessageStoreFactoryExceptionWrapper", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  result = (FIX::MessageStoreFactoryExceptionWrapper *)new FIX::MessageStoreFactoryExceptionWrapper(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreFactoryExceptionWrapper_create(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  bool *arg3 = 0 ;
  FIX::ConfigError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FIX::MessageStore *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreFactoryExceptionWrapper *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactoryExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bool &","create", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","create", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FIX__ConfigError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::ConfigError &","create", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::ConfigError &","create", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< FIX::ConfigError * >(argp4);
  result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2,*arg3,*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreFactoryExceptionWrapper_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreFactoryExceptionWrapper *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactoryExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStore *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageStoreFactoryExceptionWrapper(FIX::MessageStoreFactoryExceptionWrapper *arg1) {
    delete arg1;
}

swig_class SwigClassMessageStoreExceptionWrapper;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MessageStoreExceptionWrapper_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__MessageStoreExceptionWrapper);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MessageStoreExceptionWrapper(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageStoreExceptionWrapper";
  FIX::MessageStoreExceptionWrapper *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStore *","FIX::MessageStoreExceptionWrapper", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  result = (FIX::MessageStoreExceptionWrapper *)new FIX::MessageStoreExceptionWrapper(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageStoreExceptionWrapper(FIX::MessageStoreExceptionWrapper *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_set(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  bool *arg4 = 0 ;
  FIX::IOException *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","set", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","set", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "bool &","set", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","set", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< bool * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FIX::IOException &","set", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","set", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< FIX::IOException * >(argp5);
  result = (bool)(arg1)->set(arg2,(std::string const &)*arg3,*arg4,*arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_get(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  bool *arg5 = 0 ;
  FIX::IOException *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","get", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","get", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::string > &","get", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string > &","get", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "bool &","get", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","get", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< bool * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FIX::IOException &","get", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","get", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< FIX::IOException * >(argp6);
  ((FIX::MessageStoreExceptionWrapper const *)arg1)->get(arg2,arg3,*arg4,*arg5,*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  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 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper const *","getNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","getNextSenderMsgSeqNum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","getNextSenderMsgSeqNum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","getNextSenderMsgSeqNum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","getNextSenderMsgSeqNum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  result = (int)((FIX::MessageStoreExceptionWrapper const *)arg1)->getNextSenderMsgSeqNum(*arg2,*arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  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 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper const *","getNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","getNextTargetMsgSeqNum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","getNextTargetMsgSeqNum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","getNextTargetMsgSeqNum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","getNextTargetMsgSeqNum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  result = (int)((FIX::MessageStoreExceptionWrapper const *)arg1)->getNextTargetMsgSeqNum(*arg2,*arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  bool *arg3 = 0 ;
  FIX::IOException *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","setNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextSenderMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bool &","setNextSenderMsgSeqNum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","setNextSenderMsgSeqNum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::IOException &","setNextSenderMsgSeqNum", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","setNextSenderMsgSeqNum", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  (arg1)->setNextSenderMsgSeqNum(arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  bool *arg3 = 0 ;
  FIX::IOException *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","setNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextTargetMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bool &","setNextTargetMsgSeqNum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","setNextTargetMsgSeqNum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::IOException &","setNextTargetMsgSeqNum", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","setNextTargetMsgSeqNum", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  (arg1)->setNextTargetMsgSeqNum(arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","incrNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","incrNextSenderMsgSeqNum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","incrNextSenderMsgSeqNum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","incrNextSenderMsgSeqNum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","incrNextSenderMsgSeqNum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  (arg1)->incrNextSenderMsgSeqNum(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","incrNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","incrNextTargetMsgSeqNum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","incrNextTargetMsgSeqNum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","incrNextTargetMsgSeqNum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","incrNextTargetMsgSeqNum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  (arg1)->incrNextTargetMsgSeqNum(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_getCreationTime(int argc, VALUE *argv, VALUE self) {
  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 ;
  UtcTimeStamp result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","getCreationTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","getCreationTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","getCreationTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","getCreationTime", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","getCreationTime", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  result = (arg1)->getCreationTime(*arg2,*arg3);
  vresult = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_reset(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","reset", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","reset", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","reset", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","reset", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  (arg1)->reset(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MessageStoreExceptionWrapper_refresh(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::MessageStoreExceptionWrapper *","refresh", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool &","refresh", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","refresh", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::IOException &","refresh", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::IOException &","refresh", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  (arg1)->refresh(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassFileStoreFactory;

SWIGINTERN VALUE
_wrap_new_FileStoreFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileStoreFactory";
  FIX::FileStoreFactory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::FileStoreFactory", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::FileStoreFactory", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  result = (FIX::FileStoreFactory *)new FIX::FileStoreFactory((FIX::SessionSettings const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FileStoreFactory_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FileStoreFactory_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FileStoreFactory);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FileStoreFactory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileStoreFactory";
  FIX::FileStoreFactory *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::FileStoreFactory", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::FileStoreFactory", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (FIX::FileStoreFactory *)new FIX::FileStoreFactory((std::string const &)*arg1);
  DATA_PTR(self) = result;
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FileStoreFactory(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStoreFactory__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStoreFactory__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FileStoreFactory.new", 
    "    FileStoreFactory.new(FIX::SessionSettings const &settings)\n"
    "    FileStoreFactory.new(std::string const &path)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStoreFactory_create(int argc, VALUE *argv, VALUE self) {
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::MessageStore *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStoreFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","create", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","create", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStoreFactory_destroy(int argc, VALUE *argv, VALUE self) {
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStoreFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStore *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_FileStoreFactory(FIX::FileStoreFactory *arg1) {
    delete arg1;
}

swig_class SwigClassFileStore;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FileStore_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FileStore_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__FileStore);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FileStore(int argc, VALUE *argv, VALUE self) {
  std::string arg1 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileStore";
  FIX::FileStore *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","FIX::FileStore", 1, argv[0] )); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","FIX::FileStore", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","FIX::FileStore", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::FileStore *)new FIX::FileStore(arg1,(FIX::SessionID const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_FileStore(FIX::FileStore *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FileStore_set(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","set", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","set", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  try {
    result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_get(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","get", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","get", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::string > &","get", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string > &","get", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  try {
    ((FIX::FileStore const *)arg1)->get(arg2,arg3,*arg4);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_getNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore const *","getNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    result = (int)((FIX::FileStore const *)arg1)->getNextSenderMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_getNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore const *","getNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    result = (int)((FIX::FileStore const *)arg1)->getNextTargetMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_setNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","setNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextSenderMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextSenderMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_setNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","setNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNextTargetMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  try {
    (arg1)->setNextTargetMsgSeqNum(arg2);
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_incrNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","incrNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    (arg1)->incrNextSenderMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_incrNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","incrNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    (arg1)->incrNextTargetMsgSeqNum();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_getCreationTime(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UtcTimeStamp result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore const *","getCreationTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    result = ((FIX::FileStore const *)arg1)->getCreationTime();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_reset(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    (arg1)->reset();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStore_refresh(int argc, VALUE *argv, VALUE self) {
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::FileStore *","refresh", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    (arg1)->refresh();
  }
  catch(FIX::IOException &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IOException, SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassApplication;

SWIGINTERN void
free_FIX_Application(FIX::Application *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Application_onCreate(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","onCreate", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onCreate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onCreate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::onCreate");
    } else {
      (arg1)->onCreate((FIX::SessionID const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Application_onLogon(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","onLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onLogon", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onLogon", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::onLogon");
    } else {
      (arg1)->onLogon((FIX::SessionID const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Application_onLogout(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","onLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onLogout", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onLogout", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::onLogout");
    } else {
      (arg1)->onLogout((FIX::SessionID const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Application_toAdmin(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","toAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","toAdmin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","toAdmin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","toAdmin", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","toAdmin", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::toAdmin");
    } else {
      (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Application_toApp(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","toApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","toApp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","toApp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","toApp", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","toApp", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    try {
      if (upcall) {
        Swig::DirectorPureVirtualException::raise("FIX::Application::toApp");
      } else {
        (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
      }
    }
    catch(FIX::DoNotSend &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__DoNotSend, SWIG_NewPointerObj((new FIX::DoNotSend(static_cast< const FIX::DoNotSend& >(_e))),SWIGTYPE_p_FIX__DoNotSend,SWIG_POINTER_OWN))); SWIG_fail;
    }
    
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Application_fromAdmin(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","fromAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","fromAdmin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","fromAdmin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","fromAdmin", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","fromAdmin", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    try {
      if (upcall) {
        Swig::DirectorPureVirtualException::raise("FIX::Application::fromAdmin");
      } else {
        (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
      }
    }
    catch(FIX::FieldNotFound &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
    }
    catch(FIX::IncorrectDataFormat &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
    }
    catch(FIX::IncorrectTagValue &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN))); SWIG_fail;
    }
    catch(FIX::RejectLogon &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RejectLogon, SWIG_NewPointerObj((new FIX::RejectLogon(static_cast< const FIX::RejectLogon& >(_e))),SWIGTYPE_p_FIX__RejectLogon,SWIG_POINTER_OWN))); SWIG_fail;
    }
    
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Application_fromApp(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","fromApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","fromApp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","fromApp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","fromApp", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","fromApp", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    try {
      if (upcall) {
        Swig::DirectorPureVirtualException::raise("FIX::Application::fromApp");
      } else {
        (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
      }
    }
    catch(FIX::FieldNotFound &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
    }
    catch(FIX::IncorrectDataFormat &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
    }
    catch(FIX::IncorrectTagValue &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN))); SWIG_fail;
    }
    catch(FIX::UnsupportedMessageType &_e) {
      rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_NewPointerObj((new FIX::UnsupportedMessageType(static_cast< const FIX::UnsupportedMessageType& >(_e))),SWIGTYPE_p_FIX__UnsupportedMessageType,SWIG_POINTER_OWN))); SWIG_fail;
    }
    
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Application_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Application_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__Application);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Application(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Application";
  FIX::Application *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  arg1 = self;
  if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
    /* subclassed */
    result = (FIX::Application *)new SwigDirector_Application(arg1); 
  } else {
    rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
    return Qnil;
  }
  
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_disown_Application(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application *","disown_Application", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSynchronizedApplication;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SynchronizedApplication_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SynchronizedApplication_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SynchronizedApplication);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SynchronizedApplication(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SynchronizedApplication";
  FIX::SynchronizedApplication *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application &","FIX::SynchronizedApplication", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","FIX::SynchronizedApplication", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  result = (FIX::SynchronizedApplication *)new FIX::SynchronizedApplication(*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_onCreate(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","onCreate", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onCreate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onCreate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  (arg1)->onCreate((FIX::SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_onLogon(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","onLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onLogon", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onLogon", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  (arg1)->onLogon((FIX::SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_onLogout(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","onLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onLogout", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onLogout", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  (arg1)->onLogout((FIX::SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_toAdmin(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","toAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","toAdmin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","toAdmin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","toAdmin", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","toAdmin", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_toApp(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","toApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","toApp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","toApp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","toApp", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","toApp", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
  }
  catch(FIX::DoNotSend &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__DoNotSend, SWIG_NewPointerObj((new FIX::DoNotSend(static_cast< const FIX::DoNotSend& >(_e))),SWIGTYPE_p_FIX__DoNotSend,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_fromAdmin(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","fromAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","fromAdmin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","fromAdmin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","fromAdmin", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","fromAdmin", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectTagValue &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RejectLogon &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RejectLogon, SWIG_NewPointerObj((new FIX::RejectLogon(static_cast< const FIX::RejectLogon& >(_e))),SWIGTYPE_p_FIX__RejectLogon,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_fromApp(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","fromApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","fromApp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","fromApp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","fromApp", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","fromApp", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectTagValue &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::UnsupportedMessageType &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_NewPointerObj((new FIX::UnsupportedMessageType(static_cast< const FIX::UnsupportedMessageType& >(_e))),SWIGTYPE_p_FIX__UnsupportedMessageType,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_mutex_set(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  Mutex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_mutex", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Mutex,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Mutex","m_mutex", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Mutex","m_mutex", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Mutex * >(argp2));
    }
  }
  if (arg1) (arg1)->m_mutex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_mutex_get(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Mutex result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_mutex", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  result =  ((arg1)->m_mutex);
  vresult = SWIG_NewPointerObj((new Mutex(static_cast< const Mutex& >(result))), SWIGTYPE_p_Mutex, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_app(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","app", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  result = (FIX::Application *) &(arg1)->app();
  director = dynamic_cast<Swig::Director *>(result);
  if (director) {
    vresult = director->swig_get_self();
  } else {
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_app_set(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Application *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_app", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Application &","m_app", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","m_app", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Application * >(argp2);
  if (arg1) (arg1)->m_app = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_app_get(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Application *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_app", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  result = (FIX::Application *) &(FIX::Application &) ((arg1)->m_app);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_SynchronizedApplication(FIX::SynchronizedApplication *arg1) {
    delete arg1;
}

swig_class SwigClassNullApplication;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_NullApplication_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_NullApplication_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__NullApplication);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_NullApplication(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::NullApplication";
  FIX::NullApplication *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::NullApplication *)new FIX::NullApplication();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_NullApplication(FIX::NullApplication *arg1) {
    delete arg1;
}

swig_class SwigClassInitiator;

SWIGINTERN void
free_FIX_Initiator(FIX::Initiator *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Initiator_start(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","start", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  try {
    (arg1)->start();
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_block(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","block", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  try {
    (arg1)->block();
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_poll__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","poll", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","poll", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  try {
    result = (bool)(arg1)->poll(arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_poll__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","poll", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  try {
    result = (bool)(arg1)->poll();
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Initiator_poll(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Initiator_poll__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Initiator_poll__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Initiator.poll", 
    "    bool Initiator.poll(double timeout)\n"
    "    bool Initiator.poll()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_stop__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","stop", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","stop", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->stop(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_stop__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","stop", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  (arg1)->stop();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Initiator_stop(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Initiator_stop__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Initiator_stop__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Initiator.stop", 
    "    void Initiator.stop(bool force)\n"
    "    void Initiator.stop()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_isLoggedOn(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","isLoggedOn", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  result = (bool)(arg1)->isLoggedOn();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getSession__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  Responder *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","getSession", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","getSession", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","getSession", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Responder,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Responder &","getSession", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Responder &","getSession", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Responder * >(argp3);
  result = (FIX::Session *)(arg1)->getSession((FIX::SessionID const &)*arg2,*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getSessions(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::set< FIX::SessionID > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator const *","getSessions", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  result = (std::set< FIX::SessionID > *) &((FIX::Initiator const *)arg1)->getSessions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getSession__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator const *","getSession", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","getSession", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","getSession", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Session *)((FIX::Initiator const *)arg1)->getSession((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Initiator_getSession(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Initiator_getSession__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Responder, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Initiator_getSession__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Initiator.getSession", 
    "    FIX::Session * Initiator.getSession(FIX::SessionID const &sessionID, Responder &)\n"
    "    FIX::Session * Initiator.getSession(FIX::SessionID const &sessionID)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getSessionSettings(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Dictionary *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator const *","getSessionSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","getSessionSettings", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","getSessionSettings", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Dictionary *)((FIX::Initiator const *)arg1)->getSessionSettings((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_has(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","has", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","has", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","has", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (bool)(arg1)->has((FIX::SessionID const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_isStopped(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","isStopped", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  result = (bool)(arg1)->isStopped();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getApplication(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","getApplication", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  result = (FIX::Application *) &(arg1)->getApplication();
  director = dynamic_cast<Swig::Director *>(result);
  if (director) {
    vresult = director->swig_get_self();
  } else {
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getMessageStoreFactory(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::MessageStoreFactory *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","getMessageStoreFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  result = (FIX::MessageStoreFactory *) &(arg1)->getMessageStoreFactory();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getLog(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Initiator *","getLog", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  result = (FIX::Log *)(arg1)->getLog();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSocketInitiatorBase;

SWIGINTERN VALUE
_wrap_new_SocketInitiatorBase__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketInitiatorBase";
  FIX::SocketInitiator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application &","FIX::SocketInitiator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","FIX::SocketInitiator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory &","FIX::SocketInitiator", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MessageStoreFactory &","FIX::SocketInitiator", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::SocketInitiator", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::SocketInitiator", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  try {
    result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SocketInitiatorBase_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SocketInitiatorBase_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SocketInitiator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SocketInitiatorBase__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketInitiatorBase";
  FIX::SocketInitiator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application &","FIX::SocketInitiator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","FIX::SocketInitiator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory &","FIX::SocketInitiator", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MessageStoreFactory &","FIX::SocketInitiator", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::SocketInitiator", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::SocketInitiator", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::LogFactory &","FIX::SocketInitiator", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LogFactory &","FIX::SocketInitiator", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  try {
    result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SocketInitiatorBase(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SocketInitiatorBase__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SocketInitiatorBase__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SocketInitiator.new", 
    "    SocketInitiator.new(FIX::Application &, FIX::MessageStoreFactory &, FIX::SessionSettings const &)\n"
    "    SocketInitiator.new(FIX::Application &, FIX::MessageStoreFactory &, FIX::SessionSettings const &, FIX::LogFactory &)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketInitiator(FIX::SocketInitiator *arg1) {
    delete arg1;
}

swig_class SwigClassAcceptor;

SWIGINTERN void
free_FIX_Acceptor(FIX::Acceptor *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Acceptor_getLog(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Log *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","getLog", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  result = (FIX::Log *)(arg1)->getLog();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_start(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","start", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  try {
    (arg1)->start();
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_block(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","block", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  try {
    (arg1)->block();
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_poll__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","poll", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","poll", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  try {
    result = (bool)(arg1)->poll(arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_poll__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","poll", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  try {
    result = (bool)(arg1)->poll();
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RuntimeError, SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Acceptor_poll(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Acceptor_poll__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Acceptor_poll__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Acceptor.poll", 
    "    bool Acceptor.poll(double timeout)\n"
    "    bool Acceptor.poll()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_stop__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","stop", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","stop", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->stop(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_stop__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","stop", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  (arg1)->stop();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Acceptor_stop(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Acceptor_stop__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Acceptor_stop__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Acceptor.stop", 
    "    void Acceptor.stop(bool force)\n"
    "    void Acceptor.stop()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_isLoggedOn(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","isLoggedOn", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  result = (bool)(arg1)->isLoggedOn();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getSession__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","getSession", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getSession", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getSession", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Responder,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Responder &","getSession", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Responder &","getSession", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Responder * >(argp3);
  result = (FIX::Session *)(arg1)->getSession((std::string const &)*arg2,*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getSessions(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::set< FIX::SessionID > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor const *","getSessions", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  result = (std::set< FIX::SessionID > *) &((FIX::Acceptor const *)arg1)->getSessions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getSession__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Session *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor const *","getSession", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","getSession", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","getSession", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Session *)((FIX::Acceptor const *)arg1)->getSession((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Acceptor_getSession(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Acceptor_getSession__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Responder, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Acceptor_getSession__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Acceptor.getSession", 
    "    FIX::Session * Acceptor.getSession(std::string const &msg, Responder &)\n"
    "    FIX::Session * Acceptor.getSession(FIX::SessionID const &sessionID)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getSessionSettings(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FIX::Dictionary *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor const *","getSessionSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","getSessionSettings", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","getSessionSettings", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (FIX::Dictionary *)((FIX::Acceptor const *)arg1)->getSessionSettings((FIX::SessionID const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_has(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","has", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","has", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","has", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  result = (bool)(arg1)->has((FIX::SessionID const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_isStopped(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","isStopped", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  result = (bool)(arg1)->isStopped();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getApplication(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","getApplication", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  result = (FIX::Application *) &(arg1)->getApplication();
  director = dynamic_cast<Swig::Director *>(result);
  if (director) {
    vresult = director->swig_get_self();
  } else {
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getMessageStoreFactory(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::MessageStoreFactory *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Acceptor *","getMessageStoreFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  result = (FIX::MessageStoreFactory *) &(arg1)->getMessageStoreFactory();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSocketAcceptorBase;

SWIGINTERN VALUE
_wrap_new_SocketAcceptorBase__SWIG_0(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketAcceptorBase";
  FIX::SocketAcceptor *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application &","FIX::SocketAcceptor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","FIX::SocketAcceptor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory &","FIX::SocketAcceptor", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MessageStoreFactory &","FIX::SocketAcceptor", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::SocketAcceptor", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::SocketAcceptor", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  try {
    result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SocketAcceptorBase_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SocketAcceptorBase_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__SocketAcceptor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SocketAcceptorBase__SWIG_1(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketAcceptorBase";
  FIX::SocketAcceptor *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application &","FIX::SocketAcceptor", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","FIX::SocketAcceptor", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::MessageStoreFactory &","FIX::SocketAcceptor", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::MessageStoreFactory &","FIX::SocketAcceptor", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionSettings const &","FIX::SocketAcceptor", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionSettings const &","FIX::SocketAcceptor", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FIX::LogFactory &","FIX::SocketAcceptor", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::LogFactory &","FIX::SocketAcceptor", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  try {
    result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SocketAcceptorBase(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SocketAcceptorBase__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SocketAcceptorBase__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SocketAcceptor.new", 
    "    SocketAcceptor.new(FIX::Application &, FIX::MessageStoreFactory &, FIX::SessionSettings const &)\n"
    "    SocketAcceptor.new(FIX::Application &, FIX::MessageStoreFactory &, FIX::SessionSettings const &, FIX::LogFactory &)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketAcceptor(FIX::SocketAcceptor *arg1) {
    delete arg1;
}

swig_class SwigClassDataDictionary;

SWIGINTERN VALUE
_wrap_new_DataDictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  FIX::DataDictionary *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FIX::DataDictionary *)new FIX::DataDictionary();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DataDictionary__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  FIX::DataDictionary *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","FIX::DataDictionary", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","FIX::DataDictionary", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  result = (FIX::DataDictionary *)new FIX::DataDictionary((FIX::DataDictionary const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DataDictionary__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  FIX::DataDictionary *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::istream &","FIX::DataDictionary", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::istream &","FIX::DataDictionary", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  try {
    result = (FIX::DataDictionary *)new FIX::DataDictionary(*arg1);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_DataDictionary_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_DataDictionary_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FIX__DataDictionary);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_DataDictionary__SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  FIX::DataDictionary *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","FIX::DataDictionary", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","FIX::DataDictionary", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  try {
    result = (FIX::DataDictionary *)new FIX::DataDictionary((std::string const &)*arg1);
    DATA_PTR(self) = result;
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DataDictionary(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DataDictionary__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "DataDictionary.new", 
    "    DataDictionary.new()\n"
    "    DataDictionary.new(FIX::DataDictionary const &copy)\n"
    "    DataDictionary.new(std::istream &stream)\n"
    "    DataDictionary.new(std::string const &url)\n");
  
  return Qnil;
}


SWIGINTERN void
free_FIX_DataDictionary(FIX::DataDictionary *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DataDictionary_readFromURL(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","readFromURL", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","readFromURL", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","readFromURL", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  try {
    (arg1)->readFromURL((std::string const &)*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_readFromDocument(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  DOMDocumentPtr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","readFromDocument", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_DOMDocumentPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "DOMDocumentPtr","readFromDocument", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "DOMDocumentPtr","readFromDocument", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< DOMDocumentPtr * >(argp2));
    }
  }
  try {
    (arg1)->readFromDocument(arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_readFromStream(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","readFromStream", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::istream &","readFromStream", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::istream &","readFromStream", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  try {
    (arg1)->readFromStream(*arg2);
  }
  catch(FIX::ConfigError &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_getOrderedFields(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  message_order *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getOrderedFields", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  result = (message_order *) &((FIX::DataDictionary const *)arg1)->getOrderedFields();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_setVersion(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","setVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setVersion", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setVersion", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setVersion((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_getVersion(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  result = ((FIX::DataDictionary const *)arg1)->getVersion();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addField(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addField(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addFieldName(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addFieldName", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addFieldName", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","addFieldName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addFieldName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->addFieldName(arg2,(std::string const &)*arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary__getFieldName(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getFieldName", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFieldName", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    temp3 = std::string((char*)STR2CSTR(argv[1]));
    arg3 = &temp3;
  }
  result = (bool)((FIX::DataDictionary const *)arg1)->getFieldName(arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary__getFieldTag(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string arg2 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp3 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getFieldTag", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","getFieldTag", 2, argv[0] )); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    temp3 = NUM2INT(argv[1]);
    arg3 = &temp3;
  }
  result = (bool)((FIX::DataDictionary const *)arg1)->getFieldTag(arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("int &") == "int &" )
    {
      vresult = result ? SWIG_From_int(static_cast< int >(*arg3)) : Qnil;
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addValueName(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addValueName", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addValueName", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","addValueName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addValueName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::string const &","addValueName", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addValueName", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->addValueName(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  vresult = rb_ary_new();
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary__getValueName(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getValueName", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getValueName", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","getValueName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getValueName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    temp4 = std::string((char*)STR2CSTR(argv[2]));
    arg4 = &temp4;
  }
  result = (bool)((FIX::DataDictionary const *)arg1)->getValueName(arg2,(std::string const &)*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[2], 0 );
      rb_str_append( argv[2], rb_str_new2(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isField(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::DataDictionary const *)arg1)->isField(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addMsgType(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addMsgType", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addMsgType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addMsgType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addMsgType((std::string const &)*arg2);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isMsgType(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMsgType", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isMsgType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isMsgType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((FIX::DataDictionary const *)arg1)->isMsgType((std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addMsgField(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addMsgField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addMsgField", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addMsgField", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addMsgField", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addMsgField((std::string const &)*arg2,arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isMsgField(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMsgField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isMsgField", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isMsgField", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","isMsgField", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)((FIX::DataDictionary const *)arg1)->isMsgField((std::string const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addHeaderField(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addHeaderField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addHeaderField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","addHeaderField", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->addHeaderField(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isHeaderField(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isHeaderField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isHeaderField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::DataDictionary const *)arg1)->isHeaderField(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addTrailerField(int argc, VALUE *argv, VALUE self) {
  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 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addTrailerField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addTrailerField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","addTrailerField", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->addTrailerField(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isTrailerField(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isTrailerField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isTrailerField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::DataDictionary const *)arg1)->isTrailerField(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addFieldType(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  FIX::TYPE::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addFieldType", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addFieldType", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__TYPE__Type,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::TYPE::Type","addFieldType", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TYPE::Type","addFieldType", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< FIX::TYPE::Type * >(argp3));
    }
  }
  (arg1)->addFieldType(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_getFieldType(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getFieldType", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFieldType", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__TYPE__Type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::TYPE::Type &","getFieldType", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TYPE::Type &","getFieldType", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::TYPE::Type * >(argp3);
  result = (bool)((FIX::DataDictionary const *)arg1)->getFieldType(arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addRequiredField(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addRequiredField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addRequiredField", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addRequiredField", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addRequiredField", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addRequiredField((std::string const &)*arg2,arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isRequiredField(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isRequiredField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isRequiredField", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isRequiredField", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","isRequiredField", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)((FIX::DataDictionary const *)arg1)->isRequiredField((std::string const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addFieldValue(int argc, VALUE *argv, VALUE self) {
  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 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addFieldValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addFieldValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","addFieldValue", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addFieldValue", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->addFieldValue(arg2,(std::string const &)*arg3);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_hasFieldValue(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","hasFieldValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","hasFieldValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::DataDictionary const *)arg1)->hasFieldValue(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isFieldValue(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isFieldValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isFieldValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","isFieldValue", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isFieldValue", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)((FIX::DataDictionary const *)arg1)->isFieldValue(arg2,(std::string const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_addGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  int res5 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","addGroup", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","addGroup", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","addGroup", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  (arg1)->addGroup((std::string const &)*arg2,arg3,arg4,(FIX::DataDictionary const &)*arg5);
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","isGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)((FIX::DataDictionary const *)arg1)->isGroup((std::string const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary__getGroup(int argc, VALUE *argv, VALUE self) {
  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 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    temp4 = NUM2INT(argv[2]);
    arg4 = &temp4;
  }
  {
    arg5 = new FIX::DataDictionary*[1];
    *arg5 = temp5;
  }
  result = (bool)((FIX::DataDictionary const *)arg1)->getGroup((std::string const &)*arg2,arg3,*arg4,(FIX::DataDictionary const *&)*arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[0], 0 );
      rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
    }
  }
  {
    if( std::string("int &") == "int &" )
    {
      vresult = result ? SWIG_From_int(static_cast< int >(*arg4)) : Qnil;
    }
  }
  {
    void* argp;
    FIX::DataDictionary* pDD = 0;
    int res = SWIG_ConvertPtr(argv[3], &argp, SWIGTYPE_p_FIX__DataDictionary, 0 );
    pDD = reinterpret_cast< FIX::DataDictionary * >(argp);
    *pDD = *(*arg5);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isDataField(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isDataField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isDataField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::DataDictionary const *)arg1)->isDataField(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_isMultipleValueField(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMultipleValueField", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isMultipleValueField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((FIX::DataDictionary const *)arg1)->isMultipleValueField(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_checkFieldsOutOfOrder(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","checkFieldsOutOfOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkFieldsOutOfOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->checkFieldsOutOfOrder(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_checkFieldsHaveValues(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","checkFieldsHaveValues", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkFieldsHaveValues", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->checkFieldsHaveValues(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_checkUserDefinedFields(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","checkUserDefinedFields", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkUserDefinedFields", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->checkUserDefinedFields(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_validate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = 0 ;
  FIX::DataDictionary *arg2 = (FIX::DataDictionary *) (FIX::DataDictionary *)0 ;
  FIX::DataDictionary *arg3 = (FIX::DataDictionary *) (FIX::DataDictionary *)0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Message const &","FIX::DataDictionary::validate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","FIX::DataDictionary::validate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::DataDictionary const *const","FIX::DataDictionary::validate", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::DataDictionary const *const","FIX::DataDictionary::validate", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  try {
    FIX::DataDictionary::validate((FIX::Message const &)*arg1,(FIX::DataDictionary const *)arg2,(FIX::DataDictionary const *)arg3);
  }
  catch(FIX::Exception &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__Exception, SWIG_NewPointerObj((new FIX::Exception(static_cast< const FIX::Exception& >(_e))),SWIGTYPE_p_FIX__Exception,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_validate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  FIX::Message *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","validate", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","validate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","validate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  try {
    ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2);
  }
  catch(FIX::Exception &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__Exception, SWIG_NewPointerObj((new FIX::Exception(static_cast< const FIX::Exception& >(_e))),SWIGTYPE_p_FIX__Exception,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataDictionary_validate__SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  FIX::Message *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","validate", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","validate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","validate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","validate", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  try {
    ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2,arg3);
  }
  catch(FIX::Exception &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__Exception, SWIG_NewPointerObj((new FIX::Exception(static_cast< const FIX::Exception& >(_e))),SWIGTYPE_p_FIX__Exception,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DataDictionary_validate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DataDictionary_validate__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DataDictionary_validate__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "DataDictionary.validate", 
    "    void DataDictionary.validate(FIX::DataDictionary const *const pSessionDD, FIX::DataDictionary const *const pAppID)\n"
    "    void DataDictionary.validate(FIX::Message const &message)\n"
    "    void DataDictionary.validate(FIX::Message const &message, bool bodyOnly)\n");
  
  return Qnil;
}



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

static void *_p_FIX__CheckSumTo_p_FIX__CheckSumField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CheckSumField *)  ((FIX::CheckSum *) x));
}
static void *_p_FIX__NullLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::NullLog *) x));
}
static void *_p_FIX__FileLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::FileLog *) x));
}
static void *_p_FIX__ScreenLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::ScreenLog *) x));
}
static void *_p_IntArrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((IntArray *) x));
}
static void *_p_FIX__SocketInitiatorTo_p_FIX__Initiator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Initiator *)  ((FIX::SocketInitiator *) x));
}
static void *_p_FIX__SocketAcceptorTo_p_FIX__Acceptor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Acceptor *)  ((FIX::SocketAcceptor *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MDEntryType *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RegistStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrdStatus *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MatchStatus *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BidTradeType *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TradeType *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OpenClose *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Urgency *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::EmailType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOITransType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AllocTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RegistTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecType *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TimeInForce *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OwnershipType *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BookingUnit *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerAction *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ProcessCode *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LotType *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegSide *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TickDirection *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MsgDirection *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BasisPxType *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::VenueType *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::HandlInst *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCategory *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CxlType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CommType *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Benchmark *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlType *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DeleteReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DKReason *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CancellationRights *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CashMargin *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Rule80A *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AdvSide *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SideTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Side *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrdType *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__GroupTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Group *) x));
}
static void *_p_FIX__HeaderTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Header *) x));
}
static void *_p_FIX__TrailerTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Trailer *) x));
}
static void *_p_FIX__MessageTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Message *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCFICode *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartCash *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityType *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuantityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QtyType *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__AccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Account *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocAccount *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DeleteReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DKReason *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserRequestID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginExcess *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidPx *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastQty *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastQty *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskID *) x));
}
static void *_p_FIX__CheckSumFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::CheckSumField *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Username *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeValue *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedText *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MarketDepth *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRptID *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegNumber *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosType *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContAmtType *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosAmtType *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ReportedPx *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastFragment *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStipulations *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ShortQty *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SellerDays *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TierCode *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Benchmark *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TransferReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocText *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StopPx *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossType *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelay *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCategory *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsCategory *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardNumber *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPositions *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDates *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardStartDate *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartDate *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RefreshQty *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigTime *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteType *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumBidders *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RptSeq *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OwnerType *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TickRuleType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Currency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CommCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeType *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidTradeType *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Seniority *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinQty *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Scope *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvRefID *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BookingUnit *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDReportID *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CancellationRights *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXML *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RawData *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HandlInst *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdType *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegFactor *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchType *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmType *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollApplType *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CashMargin *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderPercent *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CrossPercent *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EventTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CreditRating *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CxlQty *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DividendYield *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegModel *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastPx *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FloorPrice *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PutOrCall *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegs *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlType *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CPRegType *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__FactorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Factor *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExpiration *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OwnershipType *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionScope *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDestination *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Designation *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Urgency *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowPx *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRef *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSize *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RFQReqID *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideQty *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::XmlData *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumTickets *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRpts *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeCondition *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidYield *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidYield *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderID *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefOrderID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReferencePage *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InputSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FairValue *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRespID *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationValue *) x));
}
static void *_p_FIX__CharFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::CharField *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMode *) x));
}
static void *_p_FIX__CountryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Country *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Rule80A *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LongQty *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegSwapType *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillQty *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocReportType *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportType *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Password *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewPassword *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReportType *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EventType *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RespondentType *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceDelta *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue2 *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbol *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSymbol *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::VenueType *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TimeInForce *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AdvSide *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Signature *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SendingDate *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistID *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientBidID *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatsType *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Symbol *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSides *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportToExch *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Subject *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidPx *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Adjustment *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetSubID *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferPx *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPool *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OpenInterest *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideValueInd *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDOriginType *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RoutingID *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SendingTime *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListExecInst *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LinesOfText *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIid *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DueToRelated *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DlvyInst *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecureData *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDMkt *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExpireDate *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BookingRefID *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TickIncrement *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecType *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingDtls *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ModelType *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventText *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransactTime *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsRefID *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDEntryType *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgParPx *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAllocs *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDtls *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingInst *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPrice *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRefID *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRateSources *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocPrice *) x));
}
static void *_p_FIX__StringFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::StringField *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegScope *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecRefID *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LotType *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::EmailType *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OptAttribute *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlLocation *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExpireTime *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RestructuringType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RoutingType *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BookingType *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatusValue *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListID *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BasisPxType *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskType *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RndPx *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HopCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderCompID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCompID *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListStatusType *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__TextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Text *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PoolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Pool *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistEmail *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ComplianceID *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartySubID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvId *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListID *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefTagID *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDStreamID *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RptSys *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegQty *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktBidPx *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideExecID *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegMoveType *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientID *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SignatureLength *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDSecSize *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinLotSize *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDay *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIShares *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocShares *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CcyAmt *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoHops *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIID *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FillExecID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Spread *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementID *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraBroker *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecBroker *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDate *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__Price2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price2 *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__YieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Yield *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlPrice *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssuer *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqType *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReqType *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastShares *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Shares *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldType *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNo *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmID *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StatusText *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserStatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Headline *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DatedDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplID *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplID *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRefID *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CapPrice *) x));
}
static void *_p_FIX__IntFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::IntField *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundLot *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RejectText *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HopRefID *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikes *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Issuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillPx *) x));
}
static void *_p_FIX__CheckSumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CheckSumField *) ((FIX::CheckSum *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferYield *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocationID *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::URLLink *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContingencyType *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PosAmt *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastParPx *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BeginString *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNum *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MsgType *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefMsgType *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoFills *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIQty *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BuyVolume *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradeVolume *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::StrikeTime *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ForexReq *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessID *) x));
}
static void *_p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeStampField *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::OddLot *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LanguageCode *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsRefType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__BoolFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::BoolField *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraTrader *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrades *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Volatility *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastMkt *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefAllocID *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SellVolume *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardExpDate *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSide *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidID *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCapacities *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuantityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDate *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MsgDirection *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TickDirection *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::WaveNo *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighPx *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossResend *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgPx *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSourceType *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrders *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegDifference *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CorporateAction *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsID *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CPProgram *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosTransType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOITransType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocTransType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvTransType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecTransType *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OpenClose *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PositionEffect *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatdSym *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplExtID *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDetls *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderSubID *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationType *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TerminationType *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdID *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidType *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketID *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayCumQty *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPriceType *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegPriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndCash *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAction *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MatchStatus *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserStatus *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistStatus *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionStatus *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdStatus *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTickRules *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PositionLimit *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContAmts *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocType *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SharedCommission *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Commission *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidPx *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIRefID *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Product *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LocateReqd *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Concession *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CommType *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CumQty *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDFeedType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollReqID *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReqID *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeDate *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListName *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeOnlyField *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDReqID *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RatioQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxShow *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecs *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HostCrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CrossID *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FirstPx *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LeavesQty *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndDate *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReqID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TestReqID *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ProcessCode *) x));
}
static void *_p_FIX__UtcDateFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcDateField *) x));
}
static void *_p_FIX__DoubleFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::DoubleField *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExpQty *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSize *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpType *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlMethod *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListMethod *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__SideTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Side *) x));
}
static void *_p_FIX__MemoryStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::MemoryStore *) x));
}
static void *_p_FIX__FileStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::FileStore *) x));
}
static void *_p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::ScreenLogFactory *) x));
}
static void *_p_FIX__FileLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::FileLogFactory *) x));
}
static void *_p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::MemoryStoreFactory *) x));
}
static void *_p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::FileStoreFactory *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RFQReqID *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeCondition *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedText *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UserRequestID *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClientBidID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ReferencePage *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UserStatusText *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDFeedType *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeskType *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TransferReason *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Username *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__TextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Text *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplID *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplID *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SendingDate *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessID *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FillExecID *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideExecID *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__PoolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Pool *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationType *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MailingDtls *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocText *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClientID *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetSubID *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RelatdSym *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__CountryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Country *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CommCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Currency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDReqID *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Signature *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeDate *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DatedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::HostCrossID *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MailingInst *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrderID *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContraTrader *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRef *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecRefID *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardExpDate *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExDate *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardNumber *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LastMkt *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CreditRating *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIID *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderSubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AdvId *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::HopCompID *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmID *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EndDate *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::YieldType *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Symbol *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSymbol *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbol *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BeginString *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::WaveNo *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDtls *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Password *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NewPassword *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIQty *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefMsgType *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MsgType *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReqID *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollReqID *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXML *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BidID *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StartDate *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardStartDate *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Seniority *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListID *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListID *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListExecInst *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AdvRefID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::URLLink *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCFICode *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RoutingID *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIid *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TimeUnit *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecBroker *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContraBroker *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NewsID *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Subject *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EventText *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNum *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityType *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RejectText *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIShares *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteID *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TierCode *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Headline *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistEmail *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IDSource *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InputSource *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDay *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosType *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ComplianceID *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListName *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryID *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PartySubID *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::XmlData *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDStreamID *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReqID *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollRptID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TestReqID *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIRefID *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LanguageCode *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__AccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Account *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Issuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssuer *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Scope *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosAmtType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AdvTransType *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CPRegType *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegPool *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RawData *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketID *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DlvyInst *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeskID *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NewsRefID *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementID *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationValue *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDMkt *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuantityDate *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDate *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityTime *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Designation *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExDestination *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNo *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EventDate *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MatchType *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CorporateAction *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlLocation *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlType *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDetls *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegRefID *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BookingRefID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecureData *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RestructuringType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExpireDate *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollRespID *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RptSys *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligID *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistID *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__SynchronizedApplicationTo_p_FIX__Application(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Application *)  ((FIX::SynchronizedApplication *) x));
}
static void *_p_FIX__NullApplicationTo_p_FIX__Application(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Application *)  ((FIX::NullApplication *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__RequiredTagMissingTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RequiredTagMissing *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__InvalidTagNumberTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidTagNumber *) x));
}
static void *_p_FIX__RejectLogonTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RejectLogon *) x));
}
static void *_p_FIX__IncorrectDataFormatTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectDataFormat *) x));
}
static void *_p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::TagNotDefinedForMessage *) x));
}
static void *_p_FIX__InvalidMessageTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessage *) x));
}
static void *_p_FIX__RuntimeErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RuntimeError *) x));
}
static void *_p_FIX__MessageParseErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::MessageParseError *) x));
}
static void *_p_FIX__DuplicateFieldNumberTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DuplicateFieldNumber *) x));
}
static void *_p_FIX__DoNotSendTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DoNotSend *) x));
}
static void *_p_FIX__FieldNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::FieldNotFound *) x));
}
static void *_p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DataDictionaryNotFound *) x));
}
static void *_p_FIX__SessionNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::SessionNotFound *) x));
}
static void *_p_FIX__IOExceptionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IOException *) x));
}
static void *_p_FIX__SocketExceptionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::SocketException *) x));
}
static void *_p_FIX__ConfigErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::ConfigError *) x));
}
static void *_p_FIX__InvalidMessageTypeTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessageType *) x));
}
static void *_p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedMessageType *) x));
}
static void *_p_FIX__UnsupportedVersionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedVersion *) x));
}
static void *_p_FIX__IncorrectTagValueTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectTagValue *) x));
}
static void *_p_FIX__NoTagValueTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::NoTagValue *) x));
}
static void *_p_FIX__TagOutOfOrderTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::TagOutOfOrder *) x));
}
static void *_p_FIX__RepeatedTagTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatedTag *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__FieldConvertErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::FieldConvertError *) x));
}
static void *_p_FIX__IncorrectMessageStructureTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectMessageStructure *) x));
}
static void *_p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatingGroupCountMismatch *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPositions *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RptSeq *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumBidders *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegModel *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideValueInd *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoContAmts *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::HopRefID *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrders *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Adjustment *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListStatusType *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExpType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegProduct *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoCapacities *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Product *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegPriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RateSourceType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TerminationType *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StatsType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ContingencyType *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UserStatus *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SessionStatus *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollStatus *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocType *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MarketDepth *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollApplType *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumTickets *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegSwapType *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelay *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrades *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ModelType *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoHops *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportType *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocReportType *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReportType *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CrossType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TickRuleType *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRateSources *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegNumber *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StatusValue *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideQty *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegMoveType *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoFills *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SellerDays *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocMethod *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAllocs *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoExpiration *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegs *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMode *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegScope *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDReportID *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteType *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideLastQty *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QtyType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuantityType *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CPProgram *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EventType *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RespondentType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RateSource *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BidType *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDates *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OwnerType *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSides *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDOriginType *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStipulations *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRpts *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ContAmtType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosTransType *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReqType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NewsCategory *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NewsRefType *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LinesOfText *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionScope *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTickRules *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikes *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefTagID *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecs *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RoutingType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BookingType *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SignatureLength *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplExtID *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EventTime *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExpireTime *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::StrikeTime *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransactTime *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SendingTime *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::DueToRelated *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ForexReq *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportToExch *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LocateReqd *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PossResend *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::OddLot *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LastFragment *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__UtcDateField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcDateField *)  ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcDateField *)  ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ReportedPx *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RatioQty *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LeavesQty *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegFactor *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FloorPrice *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StopPx *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgParPx *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ShortQty *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinQty *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Commission *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SharedCommission *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CapPrice *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferYield *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidPx *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegDifference *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighPx *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastParPx *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SellVolume *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RndPx *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastQty *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayQty *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Spread *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FirstPx *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradeVolume *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BuyVolume *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidPx *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeValue *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PosAmt *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidYield *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidYield *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidPx *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillQty *) x));
}
static void *_p_FIX__PriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndCash *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Concession *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CcyAmt *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastShares *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Shares *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPrice *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegQty *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxShow *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundLot *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExpQty *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RefreshQty *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginExcess *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TickIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DividendYield *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CxlQty *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocShares *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__YieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Yield *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceDelta *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Volatility *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSize *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillPx *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__Price2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price2 *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgPx *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlPrice *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CumQty *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OpenInterest *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LongQty *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastPx *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSize *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FairValue *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowPx *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue2 *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktBidPx *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartCash *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinLotSize *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocPrice *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__FactorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Factor *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayCumQty *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CrossPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderPercent *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDSecSize *) x));
}
static swig_type_info _swigt__p_ApplVerID = {"_p_ApplVerID", "ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Application = {"_p_Application", "Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BeginString = {"_p_BeginString", "BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DOMDocumentPtr = {"_p_DOMDocumentPtr", "DOMDocumentPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Data = {"_p_Data", "Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionary = {"_p_DataDictionary", "DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionaryProvider = {"_p_DataDictionaryProvider", "DataDictionaryProvider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dictionaries = {"_p_Dictionaries", "Dictionaries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DoubleField = {"_p_DoubleField", "DoubleField *|QtyField *|PriceField *|PercentageField *|AmtField *|FloatField *|PriceOffsetField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AMT = {"_p_FIX__AMT", "FIX::AMT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Acceptor = {"_p_FIX__Acceptor", "FIX::Acceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Account = {"_p_FIX__Account", "FIX::Account *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccountType = {"_p_FIX__AccountType", "FIX::AccountType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccruedInterestAmt = {"_p_FIX__AccruedInterestAmt", "FIX::AccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccruedInterestRate = {"_p_FIX__AccruedInterestRate", "FIX::AccruedInterestRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AcctIDSource = {"_p_FIX__AcctIDSource", "FIX::AcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Adjustment = {"_p_FIX__Adjustment", "FIX::Adjustment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdjustmentType = {"_p_FIX__AdjustmentType", "FIX::AdjustmentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvId = {"_p_FIX__AdvId", "FIX::AdvId *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvRefID = {"_p_FIX__AdvRefID", "FIX::AdvRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvSide = {"_p_FIX__AdvSide", "FIX::AdvSide *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvTransType = {"_p_FIX__AdvTransType", "FIX::AdvTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffectedOrderID = {"_p_FIX__AffectedOrderID", "FIX::AffectedOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffectedSecondaryOrderID = {"_p_FIX__AffectedSecondaryOrderID", "FIX::AffectedSecondaryOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffirmStatus = {"_p_FIX__AffirmStatus", "FIX::AffirmStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AggregatedBook = {"_p_FIX__AggregatedBook", "FIX::AggregatedBook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AggressorIndicator = {"_p_FIX__AggressorIndicator", "FIX::AggressorIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementCurrency = {"_p_FIX__AgreementCurrency", "FIX::AgreementCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementDate = {"_p_FIX__AgreementDate", "FIX::AgreementDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementDesc = {"_p_FIX__AgreementDesc", "FIX::AgreementDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementID = {"_p_FIX__AgreementID", "FIX::AgreementID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccount = {"_p_FIX__AllocAccount", "FIX::AllocAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccountType = {"_p_FIX__AllocAccountType", "FIX::AllocAccountType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccruedInterestAmt = {"_p_FIX__AllocAccruedInterestAmt", "FIX::AllocAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAcctIDSource = {"_p_FIX__AllocAcctIDSource", "FIX::AllocAcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAvgPx = {"_p_FIX__AllocAvgPx", "FIX::AllocAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocCancReplaceReason = {"_p_FIX__AllocCancReplaceReason", "FIX::AllocCancReplaceReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocClearingFeeIndicator = {"_p_FIX__AllocClearingFeeIndicator", "FIX::AllocClearingFeeIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocCustomerCapacity = {"_p_FIX__AllocCustomerCapacity", "FIX::AllocCustomerCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocHandlInst = {"_p_FIX__AllocHandlInst", "FIX::AllocHandlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocID = {"_p_FIX__AllocID", "FIX::AllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocInterestAtMaturity = {"_p_FIX__AllocInterestAtMaturity", "FIX::AllocInterestAtMaturity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocIntermedReqType = {"_p_FIX__AllocIntermedReqType", "FIX::AllocIntermedReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocLinkID = {"_p_FIX__AllocLinkID", "FIX::AllocLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocLinkType = {"_p_FIX__AllocLinkType", "FIX::AllocLinkType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocMethod = {"_p_FIX__AllocMethod", "FIX::AllocMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocNetMoney = {"_p_FIX__AllocNetMoney", "FIX::AllocNetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocNoOrdersType = {"_p_FIX__AllocNoOrdersType", "FIX::AllocNoOrdersType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocPositionEffect = {"_p_FIX__AllocPositionEffect", "FIX::AllocPositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocPrice = {"_p_FIX__AllocPrice", "FIX::AllocPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocQty = {"_p_FIX__AllocQty", "FIX::AllocQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocRejCode = {"_p_FIX__AllocRejCode", "FIX::AllocRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportID = {"_p_FIX__AllocReportID", "FIX::AllocReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportRefID = {"_p_FIX__AllocReportRefID", "FIX::AllocReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportType = {"_p_FIX__AllocReportType", "FIX::AllocReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlCurrAmt = {"_p_FIX__AllocSettlCurrAmt", "FIX::AllocSettlCurrAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlCurrency = {"_p_FIX__AllocSettlCurrency", "FIX::AllocSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlInstType = {"_p_FIX__AllocSettlInstType", "FIX::AllocSettlInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocShares = {"_p_FIX__AllocShares", "FIX::AllocShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocStatus = {"_p_FIX__AllocStatus", "FIX::AllocStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocText = {"_p_FIX__AllocText", "FIX::AllocText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocTransType = {"_p_FIX__AllocTransType", "FIX::AllocTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocType = {"_p_FIX__AllocType", "FIX::AllocType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessCurr = {"_p_FIX__AllowableOneSidednessCurr", "FIX::AllowableOneSidednessCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessPct = {"_p_FIX__AllowableOneSidednessPct", "FIX::AllowableOneSidednessPct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessValue = {"_p_FIX__AllowableOneSidednessValue", "FIX::AllowableOneSidednessValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AltMDSourceID = {"_p_FIX__AltMDSourceID", "FIX::AltMDSourceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplBegSeqNum = {"_p_FIX__ApplBegSeqNum", "FIX::ApplBegSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplEndSeqNum = {"_p_FIX__ApplEndSeqNum", "FIX::ApplEndSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplExtID = {"_p_FIX__ApplExtID", "FIX::ApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplID = {"_p_FIX__ApplID", "FIX::ApplID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplLastSeqNum = {"_p_FIX__ApplLastSeqNum", "FIX::ApplLastSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplNewSeqNum = {"_p_FIX__ApplNewSeqNum", "FIX::ApplNewSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueAction = {"_p_FIX__ApplQueueAction", "FIX::ApplQueueAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueDepth = {"_p_FIX__ApplQueueDepth", "FIX::ApplQueueDepth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueMax = {"_p_FIX__ApplQueueMax", "FIX::ApplQueueMax *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueResolution = {"_p_FIX__ApplQueueResolution", "FIX::ApplQueueResolution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReportID = {"_p_FIX__ApplReportID", "FIX::ApplReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReportType = {"_p_FIX__ApplReportType", "FIX::ApplReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReqID = {"_p_FIX__ApplReqID", "FIX::ApplReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReqType = {"_p_FIX__ApplReqType", "FIX::ApplReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResendFlag = {"_p_FIX__ApplResendFlag", "FIX::ApplResendFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseError = {"_p_FIX__ApplResponseError", "FIX::ApplResponseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseID = {"_p_FIX__ApplResponseID", "FIX::ApplResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseType = {"_p_FIX__ApplResponseType", "FIX::ApplResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplSeqNum = {"_p_FIX__ApplSeqNum", "FIX::ApplSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplTotalMessageCount = {"_p_FIX__ApplTotalMessageCount", "FIX::ApplTotalMessageCount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplVerID = {"_p_FIX__ApplVerID", "FIX::ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Application = {"_p_FIX__Application", "FIX::Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsOfIndicator = {"_p_FIX__AsOfIndicator", "FIX::AsOfIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsgnRptID = {"_p_FIX__AsgnRptID", "FIX::AsgnRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AssignmentMethod = {"_p_FIX__AssignmentMethod", "FIX::AssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AssignmentUnit = {"_p_FIX__AssignmentUnit", "FIX::AssignmentUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AttachmentPoint = {"_p_FIX__AttachmentPoint", "FIX::AttachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AutoAcceptIndicator = {"_p_FIX__AutoAcceptIndicator", "FIX::AutoAcceptIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgParPx = {"_p_FIX__AvgParPx", "FIX::AvgParPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPrxPrecision = {"_p_FIX__AvgPrxPrecision", "FIX::AvgPrxPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPx = {"_p_FIX__AvgPx", "FIX::AvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPxIndicator = {"_p_FIX__AvgPxIndicator", "FIX::AvgPxIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPxPrecision = {"_p_FIX__AvgPxPrecision", "FIX::AvgPxPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BOOLEAN = {"_p_FIX__BOOLEAN", "FIX::BOOLEAN *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisFeatureDate = {"_p_FIX__BasisFeatureDate", "FIX::BasisFeatureDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisFeaturePrice = {"_p_FIX__BasisFeaturePrice", "FIX::BasisFeaturePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisPxType = {"_p_FIX__BasisPxType", "FIX::BasisPxType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BeginSeqNo = {"_p_FIX__BeginSeqNo", "FIX::BeginSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BeginString = {"_p_FIX__BeginString", "FIX::BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Benchmark = {"_p_FIX__Benchmark", "FIX::Benchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurveCurrency = {"_p_FIX__BenchmarkCurveCurrency", "FIX::BenchmarkCurveCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurveName = {"_p_FIX__BenchmarkCurveName", "FIX::BenchmarkCurveName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurvePoint = {"_p_FIX__BenchmarkCurvePoint", "FIX::BenchmarkCurvePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkPrice = {"_p_FIX__BenchmarkPrice", "FIX::BenchmarkPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkPriceType = {"_p_FIX__BenchmarkPriceType", "FIX::BenchmarkPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkSecurityID = {"_p_FIX__BenchmarkSecurityID", "FIX::BenchmarkSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkSecurityIDSource = {"_p_FIX__BenchmarkSecurityIDSource", "FIX::BenchmarkSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidDescriptor = {"_p_FIX__BidDescriptor", "FIX::BidDescriptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidDescriptorType = {"_p_FIX__BidDescriptorType", "FIX::BidDescriptorType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidForwardPoints = {"_p_FIX__BidForwardPoints", "FIX::BidForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidForwardPoints2 = {"_p_FIX__BidForwardPoints2", "FIX::BidForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidID = {"_p_FIX__BidID", "FIX::BidID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidPx = {"_p_FIX__BidPx", "FIX::BidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidRequestTransType = {"_p_FIX__BidRequestTransType", "FIX::BidRequestTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSize = {"_p_FIX__BidSize", "FIX::BidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSpotRate = {"_p_FIX__BidSpotRate", "FIX::BidSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSwapPoints = {"_p_FIX__BidSwapPoints", "FIX::BidSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidTradeType = {"_p_FIX__BidTradeType", "FIX::BidTradeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidType = {"_p_FIX__BidType", "FIX::BidType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidYield = {"_p_FIX__BidYield", "FIX::BidYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BodyLength = {"_p_FIX__BodyLength", "FIX::BodyLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingRefID = {"_p_FIX__BookingRefID", "FIX::BookingRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingType = {"_p_FIX__BookingType", "FIX::BookingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingUnit = {"_p_FIX__BookingUnit", "FIX::BookingUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BoolField = {"_p_FIX__BoolField", "FIX::BoolField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BrokerOfCredit = {"_p_FIX__BrokerOfCredit", "FIX::BrokerOfCredit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BusinessRejectReason = {"_p_FIX__BusinessRejectReason", "FIX::BusinessRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BusinessRejectRefID = {"_p_FIX__BusinessRejectRefID", "FIX::BusinessRejectRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BuyVolume = {"_p_FIX__BuyVolume", "FIX::BuyVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CFICode = {"_p_FIX__CFICode", "FIX::CFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CHAR = {"_p_FIX__CHAR", "FIX::CHAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__COUNTRY = {"_p_FIX__COUNTRY", "FIX::COUNTRY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CPProgram = {"_p_FIX__CPProgram", "FIX::CPProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CPRegType = {"_p_FIX__CPRegType", "FIX::CPRegType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CURRENCY = {"_p_FIX__CURRENCY", "FIX::CURRENCY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CalculatedCcyLastQty = {"_p_FIX__CalculatedCcyLastQty", "FIX::CalculatedCcyLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CancellationRights = {"_p_FIX__CancellationRights", "FIX::CancellationRights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CapPrice = {"_p_FIX__CapPrice", "FIX::CapPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardExpDate = {"_p_FIX__CardExpDate", "FIX::CardExpDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardHolderName = {"_p_FIX__CardHolderName", "FIX::CardHolderName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardIssNo = {"_p_FIX__CardIssNo", "FIX::CardIssNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardIssNum = {"_p_FIX__CardIssNum", "FIX::CardIssNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardNumber = {"_p_FIX__CardNumber", "FIX::CardNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardStartDate = {"_p_FIX__CardStartDate", "FIX::CardStartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentAcctName = {"_p_FIX__CashDistribAgentAcctName", "FIX::CashDistribAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentAcctNumber = {"_p_FIX__CashDistribAgentAcctNumber", "FIX::CashDistribAgentAcctNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentCode = {"_p_FIX__CashDistribAgentCode", "FIX::CashDistribAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentName = {"_p_FIX__CashDistribAgentName", "FIX::CashDistribAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribCurr = {"_p_FIX__CashDistribCurr", "FIX::CashDistribCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribPayRef = {"_p_FIX__CashDistribPayRef", "FIX::CashDistribPayRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashMargin = {"_p_FIX__CashMargin", "FIX::CashMargin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashOrderQty = {"_p_FIX__CashOrderQty", "FIX::CashOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashOutstanding = {"_p_FIX__CashOutstanding", "FIX::CashOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentAcctName = {"_p_FIX__CashSettlAgentAcctName", "FIX::CashSettlAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentAcctNum = {"_p_FIX__CashSettlAgentAcctNum", "FIX::CashSettlAgentAcctNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentCode = {"_p_FIX__CashSettlAgentCode", "FIX::CashSettlAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentContactName = {"_p_FIX__CashSettlAgentContactName", "FIX::CashSettlAgentContactName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentContactPhone = {"_p_FIX__CashSettlAgentContactPhone", "FIX::CashSettlAgentContactPhone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentName = {"_p_FIX__CashSettlAgentName", "FIX::CashSettlAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CcyAmt = {"_p_FIX__CcyAmt", "FIX::CcyAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CharField = {"_p_FIX__CharField", "FIX::CharField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CheckSum = {"_p_FIX__CheckSum", "FIX::CheckSum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CheckSumField = {"_p_FIX__CheckSumField", "FIX::CheckSumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClOrdID = {"_p_FIX__ClOrdID", "FIX::ClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClOrdLinkID = {"_p_FIX__ClOrdLinkID", "FIX::ClOrdLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingAccount = {"_p_FIX__ClearingAccount", "FIX::ClearingAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingBusinessDate = {"_p_FIX__ClearingBusinessDate", "FIX::ClearingBusinessDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingFeeIndicator = {"_p_FIX__ClearingFeeIndicator", "FIX::ClearingFeeIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingFirm = {"_p_FIX__ClearingFirm", "FIX::ClearingFirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingInstruction = {"_p_FIX__ClearingInstruction", "FIX::ClearingInstruction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClientBidID = {"_p_FIX__ClientBidID", "FIX::ClientBidID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClientID = {"_p_FIX__ClientID", "FIX::ClientID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAction = {"_p_FIX__CollAction", "FIX::CollAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollApplType = {"_p_FIX__CollApplType", "FIX::CollApplType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnID = {"_p_FIX__CollAsgnID", "FIX::CollAsgnID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnReason = {"_p_FIX__CollAsgnReason", "FIX::CollAsgnReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRefID = {"_p_FIX__CollAsgnRefID", "FIX::CollAsgnRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRejectReason = {"_p_FIX__CollAsgnRejectReason", "FIX::CollAsgnRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRespType = {"_p_FIX__CollAsgnRespType", "FIX::CollAsgnRespType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnTransType = {"_p_FIX__CollAsgnTransType", "FIX::CollAsgnTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryID = {"_p_FIX__CollInquiryID", "FIX::CollInquiryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryQualifier = {"_p_FIX__CollInquiryQualifier", "FIX::CollInquiryQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryResult = {"_p_FIX__CollInquiryResult", "FIX::CollInquiryResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryStatus = {"_p_FIX__CollInquiryStatus", "FIX::CollInquiryStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollReqID = {"_p_FIX__CollReqID", "FIX::CollReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollRespID = {"_p_FIX__CollRespID", "FIX::CollRespID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollRptID = {"_p_FIX__CollRptID", "FIX::CollRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollStatus = {"_p_FIX__CollStatus", "FIX::CollStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CommCurrency = {"_p_FIX__CommCurrency", "FIX::CommCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CommType = {"_p_FIX__CommType", "FIX::CommType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Commission = {"_p_FIX__Commission", "FIX::Commission *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventCondition = {"_p_FIX__ComplexEventCondition", "FIX::ComplexEventCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventEndDate = {"_p_FIX__ComplexEventEndDate", "FIX::ComplexEventEndDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventEndTime = {"_p_FIX__ComplexEventEndTime", "FIX::ComplexEventEndTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPrice = {"_p_FIX__ComplexEventPrice", "FIX::ComplexEventPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceBoundaryMethod = {"_p_FIX__ComplexEventPriceBoundaryMethod", "FIX::ComplexEventPriceBoundaryMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceBoundaryPrecision = {"_p_FIX__ComplexEventPriceBoundaryPrecision", "FIX::ComplexEventPriceBoundaryPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceTimeType = {"_p_FIX__ComplexEventPriceTimeType", "FIX::ComplexEventPriceTimeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventStartDate = {"_p_FIX__ComplexEventStartDate", "FIX::ComplexEventStartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventStartTime = {"_p_FIX__ComplexEventStartTime", "FIX::ComplexEventStartTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventType = {"_p_FIX__ComplexEventType", "FIX::ComplexEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexOptPayoutAmount = {"_p_FIX__ComplexOptPayoutAmount", "FIX::ComplexOptPayoutAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplianceID = {"_p_FIX__ComplianceID", "FIX::ComplianceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Concession = {"_p_FIX__Concession", "FIX::Concession *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfigError = {"_p_FIX__ConfigError", "FIX::ConfigError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmID = {"_p_FIX__ConfirmID", "FIX::ConfirmID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmRefID = {"_p_FIX__ConfirmRefID", "FIX::ConfirmRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmRejReason = {"_p_FIX__ConfirmRejReason", "FIX::ConfirmRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmReqID = {"_p_FIX__ConfirmReqID", "FIX::ConfirmReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmStatus = {"_p_FIX__ConfirmStatus", "FIX::ConfirmStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmTransType = {"_p_FIX__ConfirmTransType", "FIX::ConfirmTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmType = {"_p_FIX__ConfirmType", "FIX::ConfirmType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtCurr = {"_p_FIX__ContAmtCurr", "FIX::ContAmtCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtType = {"_p_FIX__ContAmtType", "FIX::ContAmtType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtValue = {"_p_FIX__ContAmtValue", "FIX::ContAmtValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContIntRptID = {"_p_FIX__ContIntRptID", "FIX::ContIntRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContingencyType = {"_p_FIX__ContingencyType", "FIX::ContingencyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraBroker = {"_p_FIX__ContraBroker", "FIX::ContraBroker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraLegRefID = {"_p_FIX__ContraLegRefID", "FIX::ContraLegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTradeQty = {"_p_FIX__ContraTradeQty", "FIX::ContraTradeQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTradeTime = {"_p_FIX__ContraTradeTime", "FIX::ContraTradeTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTrader = {"_p_FIX__ContraTrader", "FIX::ContraTrader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractMultiplier = {"_p_FIX__ContractMultiplier", "FIX::ContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractMultiplierUnit = {"_p_FIX__ContractMultiplierUnit", "FIX::ContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractSettlMonth = {"_p_FIX__ContractSettlMonth", "FIX::ContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraryInstructionIndicator = {"_p_FIX__ContraryInstructionIndicator", "FIX::ContraryInstructionIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CopyMsgIndicator = {"_p_FIX__CopyMsgIndicator", "FIX::CopyMsgIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CorporateAction = {"_p_FIX__CorporateAction", "FIX::CorporateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Country = {"_p_FIX__Country", "FIX::Country *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CountryOfIssue = {"_p_FIX__CountryOfIssue", "FIX::CountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CouponPaymentDate = {"_p_FIX__CouponPaymentDate", "FIX::CouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CouponRate = {"_p_FIX__CouponRate", "FIX::CouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CoveredOrUncovered = {"_p_FIX__CoveredOrUncovered", "FIX::CoveredOrUncovered *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CreditRating = {"_p_FIX__CreditRating", "FIX::CreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossID = {"_p_FIX__CrossID", "FIX::CrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossPercent = {"_p_FIX__CrossPercent", "FIX::CrossPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossPrioritization = {"_p_FIX__CrossPrioritization", "FIX::CrossPrioritization *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossType = {"_p_FIX__CrossType", "FIX::CrossType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CstmApplVerID = {"_p_FIX__CstmApplVerID", "FIX::CstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CumQty = {"_p_FIX__CumQty", "FIX::CumQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Currency = {"_p_FIX__Currency", "FIX::Currency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CurrencyRatio = {"_p_FIX__CurrencyRatio", "FIX::CurrencyRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustDirectedOrder = {"_p_FIX__CustDirectedOrder", "FIX::CustDirectedOrder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustOrderCapacity = {"_p_FIX__CustOrderCapacity", "FIX::CustOrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustOrderHandlingInst = {"_p_FIX__CustOrderHandlingInst", "FIX::CustOrderHandlingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustomerOrFirm = {"_p_FIX__CustomerOrFirm", "FIX::CustomerOrFirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlQty = {"_p_FIX__CxlQty", "FIX::CxlQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlRejReason = {"_p_FIX__CxlRejReason", "FIX::CxlRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlRejResponseTo = {"_p_FIX__CxlRejResponseTo", "FIX::CxlRejResponseTo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlType = {"_p_FIX__CxlType", "FIX::CxlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DATA = {"_p_FIX__DATA", "FIX::DATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DAYOFMONTH = {"_p_FIX__DAYOFMONTH", "FIX::DAYOFMONTH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DKReason = {"_p_FIX__DKReason", "FIX::DKReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DataDictionary = {"_p_FIX__DataDictionary", "FIX::DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DataDictionaryNotFound = {"_p_FIX__DataDictionaryNotFound", "FIX::DataDictionaryNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DateOfBirth = {"_p_FIX__DateOfBirth", "FIX::DateOfBirth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DatedDate = {"_p_FIX__DatedDate", "FIX::DatedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayAvgPx = {"_p_FIX__DayAvgPx", "FIX::DayAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayBookingInst = {"_p_FIX__DayBookingInst", "FIX::DayBookingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayCumQty = {"_p_FIX__DayCumQty", "FIX::DayCumQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayOrderQty = {"_p_FIX__DayOrderQty", "FIX::DayOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DealingCapacity = {"_p_FIX__DealingCapacity", "FIX::DealingCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefBidSize = {"_p_FIX__DefBidSize", "FIX::DefBidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefOfferSize = {"_p_FIX__DefOfferSize", "FIX::DefOfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultApplExtID = {"_p_FIX__DefaultApplExtID", "FIX::DefaultApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultApplVerID = {"_p_FIX__DefaultApplVerID", "FIX::DefaultApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultCstmApplVerID = {"_p_FIX__DefaultCstmApplVerID", "FIX::DefaultCstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultVerIndicator = {"_p_FIX__DefaultVerIndicator", "FIX::DefaultVerIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeleteReason = {"_p_FIX__DeleteReason", "FIX::DeleteReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToCompID = {"_p_FIX__DeliverToCompID", "FIX::DeliverToCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToLocationID = {"_p_FIX__DeliverToLocationID", "FIX::DeliverToLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToSubID = {"_p_FIX__DeliverToSubID", "FIX::DeliverToSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryDate = {"_p_FIX__DeliveryDate", "FIX::DeliveryDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryForm = {"_p_FIX__DeliveryForm", "FIX::DeliveryForm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryType = {"_p_FIX__DeliveryType", "FIX::DeliveryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivFlexProductEligibilityIndicator = {"_p_FIX__DerivFlexProductEligibilityIndicator", "FIX::DerivFlexProductEligibilityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCFICode = {"_p_FIX__DerivativeCFICode", "FIX::DerivativeCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCapPrice = {"_p_FIX__DerivativeCapPrice", "FIX::DerivativeCapPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractMultiplier = {"_p_FIX__DerivativeContractMultiplier", "FIX::DerivativeContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractMultiplierUnit = {"_p_FIX__DerivativeContractMultiplierUnit", "FIX::DerivativeContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractSettlMonth = {"_p_FIX__DerivativeContractSettlMonth", "FIX::DerivativeContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCountryOfIssue = {"_p_FIX__DerivativeCountryOfIssue", "FIX::DerivativeCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedIssuer = {"_p_FIX__DerivativeEncodedIssuer", "FIX::DerivativeEncodedIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedIssuerLen = {"_p_FIX__DerivativeEncodedIssuerLen", "FIX::DerivativeEncodedIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedSecurityDesc = {"_p_FIX__DerivativeEncodedSecurityDesc", "FIX::DerivativeEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedSecurityDescLen = {"_p_FIX__DerivativeEncodedSecurityDescLen", "FIX::DerivativeEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventDate = {"_p_FIX__DerivativeEventDate", "FIX::DerivativeEventDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventPx = {"_p_FIX__DerivativeEventPx", "FIX::DerivativeEventPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventText = {"_p_FIX__DerivativeEventText", "FIX::DerivativeEventText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventTime = {"_p_FIX__DerivativeEventTime", "FIX::DerivativeEventTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventType = {"_p_FIX__DerivativeEventType", "FIX::DerivativeEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeExerciseStyle = {"_p_FIX__DerivativeExerciseStyle", "FIX::DerivativeExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFloorPrice = {"_p_FIX__DerivativeFloorPrice", "FIX::DerivativeFloorPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFlowScheduleType = {"_p_FIX__DerivativeFlowScheduleType", "FIX::DerivativeFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFuturesValuationMethod = {"_p_FIX__DerivativeFuturesValuationMethod", "FIX::DerivativeFuturesValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrAttribType = {"_p_FIX__DerivativeInstrAttribType", "FIX::DerivativeInstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrAttribValue = {"_p_FIX__DerivativeInstrAttribValue", "FIX::DerivativeInstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrRegistry = {"_p_FIX__DerivativeInstrRegistry", "FIX::DerivativeInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrmtAssignmentMethod = {"_p_FIX__DerivativeInstrmtAssignmentMethod", "FIX::DerivativeInstrmtAssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyID = {"_p_FIX__DerivativeInstrumentPartyID", "FIX::DerivativeInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyIDSource = {"_p_FIX__DerivativeInstrumentPartyIDSource", "FIX::DerivativeInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyRole = {"_p_FIX__DerivativeInstrumentPartyRole", "FIX::DerivativeInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartySubID = {"_p_FIX__DerivativeInstrumentPartySubID", "FIX::DerivativeInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartySubIDType = {"_p_FIX__DerivativeInstrumentPartySubIDType", "FIX::DerivativeInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeIssueDate = {"_p_FIX__DerivativeIssueDate", "FIX::DerivativeIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeIssuer = {"_p_FIX__DerivativeIssuer", "FIX::DerivativeIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeListMethod = {"_p_FIX__DerivativeListMethod", "FIX::DerivativeListMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeLocaleOfIssue = {"_p_FIX__DerivativeLocaleOfIssue", "FIX::DerivativeLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityDate = {"_p_FIX__DerivativeMaturityDate", "FIX::DerivativeMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityMonthYear = {"_p_FIX__DerivativeMaturityMonthYear", "FIX::DerivativeMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityTime = {"_p_FIX__DerivativeMaturityTime", "FIX::DerivativeMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMinPriceIncrement = {"_p_FIX__DerivativeMinPriceIncrement", "FIX::DerivativeMinPriceIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMinPriceIncrementAmount = {"_p_FIX__DerivativeMinPriceIncrementAmount", "FIX::DerivativeMinPriceIncrementAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeNTPositionLimit = {"_p_FIX__DerivativeNTPositionLimit", "FIX::DerivativeNTPositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeOptAttribute = {"_p_FIX__DerivativeOptAttribute", "FIX::DerivativeOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeOptPayAmount = {"_p_FIX__DerivativeOptPayAmount", "FIX::DerivativeOptPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePositionLimit = {"_p_FIX__DerivativePositionLimit", "FIX::DerivativePositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceQuoteMethod = {"_p_FIX__DerivativePriceQuoteMethod", "FIX::DerivativePriceQuoteMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceUnitOfMeasure = {"_p_FIX__DerivativePriceUnitOfMeasure", "FIX::DerivativePriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceUnitOfMeasureQty = {"_p_FIX__DerivativePriceUnitOfMeasureQty", "FIX::DerivativePriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeProduct = {"_p_FIX__DerivativeProduct", "FIX::DerivativeProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeProductComplex = {"_p_FIX__DerivativeProductComplex", "FIX::DerivativeProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePutOrCall = {"_p_FIX__DerivativePutOrCall", "FIX::DerivativePutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityAltID = {"_p_FIX__DerivativeSecurityAltID", "FIX::DerivativeSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityAltIDSource = {"_p_FIX__DerivativeSecurityAltIDSource", "FIX::DerivativeSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityDesc = {"_p_FIX__DerivativeSecurityDesc", "FIX::DerivativeSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityExchange = {"_p_FIX__DerivativeSecurityExchange", "FIX::DerivativeSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityGroup = {"_p_FIX__DerivativeSecurityGroup", "FIX::DerivativeSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityID = {"_p_FIX__DerivativeSecurityID", "FIX::DerivativeSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityIDSource = {"_p_FIX__DerivativeSecurityIDSource", "FIX::DerivativeSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityStatus = {"_p_FIX__DerivativeSecurityStatus", "FIX::DerivativeSecurityStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecuritySubType = {"_p_FIX__DerivativeSecuritySubType", "FIX::DerivativeSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityType = {"_p_FIX__DerivativeSecurityType", "FIX::DerivativeSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXML = {"_p_FIX__DerivativeSecurityXML", "FIX::DerivativeSecurityXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXMLLen = {"_p_FIX__DerivativeSecurityXMLLen", "FIX::DerivativeSecurityXMLLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXMLSchema = {"_p_FIX__DerivativeSecurityXMLSchema", "FIX::DerivativeSecurityXMLSchema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSettlMethod = {"_p_FIX__DerivativeSettlMethod", "FIX::DerivativeSettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSettleOnOpenFlag = {"_p_FIX__DerivativeSettleOnOpenFlag", "FIX::DerivativeSettleOnOpenFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStateOrProvinceOfIssue = {"_p_FIX__DerivativeStateOrProvinceOfIssue", "FIX::DerivativeStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeCurrency = {"_p_FIX__DerivativeStrikeCurrency", "FIX::DerivativeStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeMultiplier = {"_p_FIX__DerivativeStrikeMultiplier", "FIX::DerivativeStrikeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikePrice = {"_p_FIX__DerivativeStrikePrice", "FIX::DerivativeStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeValue = {"_p_FIX__DerivativeStrikeValue", "FIX::DerivativeStrikeValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSymbol = {"_p_FIX__DerivativeSymbol", "FIX::DerivativeSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSymbolSfx = {"_p_FIX__DerivativeSymbolSfx", "FIX::DerivativeSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeTimeUnit = {"_p_FIX__DerivativeTimeUnit", "FIX::DerivativeTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeUnitOfMeasure = {"_p_FIX__DerivativeUnitOfMeasure", "FIX::DerivativeUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeUnitOfMeasureQty = {"_p_FIX__DerivativeUnitOfMeasureQty", "FIX::DerivativeUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeValuationMethod = {"_p_FIX__DerivativeValuationMethod", "FIX::DerivativeValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Designation = {"_p_FIX__Designation", "FIX::Designation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskID = {"_p_FIX__DeskID", "FIX::DeskID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskOrderHandlingInst = {"_p_FIX__DeskOrderHandlingInst", "FIX::DeskOrderHandlingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskType = {"_p_FIX__DeskType", "FIX::DeskType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskTypeSource = {"_p_FIX__DeskTypeSource", "FIX::DeskTypeSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DetachmentPoint = {"_p_FIX__DetachmentPoint", "FIX::DetachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Dictionary = {"_p_FIX__Dictionary", "FIX::Dictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Dictionary__Data__const_iterator = {"_p_FIX__Dictionary__Data__const_iterator", "FIX::Dictionary::Data::const_iterator *|FIX::Dictionary::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionInst = {"_p_FIX__DiscretionInst", "FIX::DiscretionInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionLimitType = {"_p_FIX__DiscretionLimitType", "FIX::DiscretionLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionMoveType = {"_p_FIX__DiscretionMoveType", "FIX::DiscretionMoveType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffset = {"_p_FIX__DiscretionOffset", "FIX::DiscretionOffset *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffsetType = {"_p_FIX__DiscretionOffsetType", "FIX::DiscretionOffsetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffsetValue = {"_p_FIX__DiscretionOffsetValue", "FIX::DiscretionOffsetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionPrice = {"_p_FIX__DiscretionPrice", "FIX::DiscretionPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionRoundDirection = {"_p_FIX__DiscretionRoundDirection", "FIX::DiscretionRoundDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionScope = {"_p_FIX__DiscretionScope", "FIX::DiscretionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayHighQty = {"_p_FIX__DisplayHighQty", "FIX::DisplayHighQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayLowQty = {"_p_FIX__DisplayLowQty", "FIX::DisplayLowQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayMethod = {"_p_FIX__DisplayMethod", "FIX::DisplayMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayMinIncr = {"_p_FIX__DisplayMinIncr", "FIX::DisplayMinIncr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayQty = {"_p_FIX__DisplayQty", "FIX::DisplayQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayWhen = {"_p_FIX__DisplayWhen", "FIX::DisplayWhen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DistribPaymentMethod = {"_p_FIX__DistribPaymentMethod", "FIX::DistribPaymentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DistribPercentage = {"_p_FIX__DistribPercentage", "FIX::DistribPercentage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DividendYield = {"_p_FIX__DividendYield", "FIX::DividendYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DlvyInst = {"_p_FIX__DlvyInst", "FIX::DlvyInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DlvyInstType = {"_p_FIX__DlvyInstType", "FIX::DlvyInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoNotSend = {"_p_FIX__DoNotSend", "FIX::DoNotSend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoubleField = {"_p_FIX__DoubleField", "FIX::DoubleField *|FIX::QtyField *|FIX::PriceField *|FIX::PercentageField *|FIX::AmtField *|FIX::FloatField *|FIX::PriceOffsetField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DueToRelated = {"_p_FIX__DueToRelated", "FIX::DueToRelated *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DuplicateFieldNumber = {"_p_FIX__DuplicateFieldNumber", "FIX::DuplicateFieldNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EFPTrackingError = {"_p_FIX__EFPTrackingError", "FIX::EFPTrackingError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EXCHANGE = {"_p_FIX__EXCHANGE", "FIX::EXCHANGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EffectiveTime = {"_p_FIX__EffectiveTime", "FIX::EffectiveTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EmailThreadID = {"_p_FIX__EmailThreadID", "FIX::EmailThreadID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EmailType = {"_p_FIX__EmailType", "FIX::EmailType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedAllocText = {"_p_FIX__EncodedAllocText", "FIX::EncodedAllocText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedAllocTextLen = {"_p_FIX__EncodedAllocTextLen", "FIX::EncodedAllocTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedHeadline = {"_p_FIX__EncodedHeadline", "FIX::EncodedHeadline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedHeadlineLen = {"_p_FIX__EncodedHeadlineLen", "FIX::EncodedHeadlineLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedIssuer = {"_p_FIX__EncodedIssuer", "FIX::EncodedIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedIssuerLen = {"_p_FIX__EncodedIssuerLen", "FIX::EncodedIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegIssuer = {"_p_FIX__EncodedLegIssuer", "FIX::EncodedLegIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegIssuerLen = {"_p_FIX__EncodedLegIssuerLen", "FIX::EncodedLegIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegSecurityDesc = {"_p_FIX__EncodedLegSecurityDesc", "FIX::EncodedLegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegSecurityDescLen = {"_p_FIX__EncodedLegSecurityDescLen", "FIX::EncodedLegSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListExecInst = {"_p_FIX__EncodedListExecInst", "FIX::EncodedListExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListExecInstLen = {"_p_FIX__EncodedListExecInstLen", "FIX::EncodedListExecInstLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListStatusText = {"_p_FIX__EncodedListStatusText", "FIX::EncodedListStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListStatusTextLen = {"_p_FIX__EncodedListStatusTextLen", "FIX::EncodedListStatusTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedMktSegmDesc = {"_p_FIX__EncodedMktSegmDesc", "FIX::EncodedMktSegmDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedMktSegmDescLen = {"_p_FIX__EncodedMktSegmDescLen", "FIX::EncodedMktSegmDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityDesc = {"_p_FIX__EncodedSecurityDesc", "FIX::EncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityDescLen = {"_p_FIX__EncodedSecurityDescLen", "FIX::EncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityListDesc = {"_p_FIX__EncodedSecurityListDesc", "FIX::EncodedSecurityListDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityListDescLen = {"_p_FIX__EncodedSecurityListDescLen", "FIX::EncodedSecurityListDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSubject = {"_p_FIX__EncodedSubject", "FIX::EncodedSubject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSubjectLen = {"_p_FIX__EncodedSubjectLen", "FIX::EncodedSubjectLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedText = {"_p_FIX__EncodedText", "FIX::EncodedText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedTextLen = {"_p_FIX__EncodedTextLen", "FIX::EncodedTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingIssuer = {"_p_FIX__EncodedUnderlyingIssuer", "FIX::EncodedUnderlyingIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingIssuerLen = {"_p_FIX__EncodedUnderlyingIssuerLen", "FIX::EncodedUnderlyingIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingSecurityDesc = {"_p_FIX__EncodedUnderlyingSecurityDesc", "FIX::EncodedUnderlyingSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingSecurityDescLen = {"_p_FIX__EncodedUnderlyingSecurityDescLen", "FIX::EncodedUnderlyingSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptMethod = {"_p_FIX__EncryptMethod", "FIX::EncryptMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedNewPassword = {"_p_FIX__EncryptedNewPassword", "FIX::EncryptedNewPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedNewPasswordLen = {"_p_FIX__EncryptedNewPasswordLen", "FIX::EncryptedNewPasswordLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPassword = {"_p_FIX__EncryptedPassword", "FIX::EncryptedPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPasswordLen = {"_p_FIX__EncryptedPasswordLen", "FIX::EncryptedPasswordLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPasswordMethod = {"_p_FIX__EncryptedPasswordMethod", "FIX::EncryptedPasswordMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndAccruedInterestAmt = {"_p_FIX__EndAccruedInterestAmt", "FIX::EndAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndCash = {"_p_FIX__EndCash", "FIX::EndCash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndDate = {"_p_FIX__EndDate", "FIX::EndDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndMaturityMonthYear = {"_p_FIX__EndMaturityMonthYear", "FIX::EndMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndSeqNo = {"_p_FIX__EndSeqNo", "FIX::EndSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndStrikePxRange = {"_p_FIX__EndStrikePxRange", "FIX::EndStrikePxRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndTickPriceRange = {"_p_FIX__EndTickPriceRange", "FIX::EndTickPriceRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventDate = {"_p_FIX__EventDate", "FIX::EventDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventPx = {"_p_FIX__EventPx", "FIX::EventPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventText = {"_p_FIX__EventText", "FIX::EventText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventTime = {"_p_FIX__EventTime", "FIX::EventTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventType = {"_p_FIX__EventType", "FIX::EventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDate = {"_p_FIX__ExDate", "FIX::ExDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDestination = {"_p_FIX__ExDestination", "FIX::ExDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDestinationIDSource = {"_p_FIX__ExDestinationIDSource", "FIX::ExDestinationIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Exception = {"_p_FIX__Exception", "FIX::Exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeForPhysical = {"_p_FIX__ExchangeForPhysical", "FIX::ExchangeForPhysical *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeRule = {"_p_FIX__ExchangeRule", "FIX::ExchangeRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeSpecialInstructions = {"_p_FIX__ExchangeSpecialInstructions", "FIX::ExchangeSpecialInstructions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecAckStatus = {"_p_FIX__ExecAckStatus", "FIX::ExecAckStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecBroker = {"_p_FIX__ExecBroker", "FIX::ExecBroker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecID = {"_p_FIX__ExecID", "FIX::ExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecInst = {"_p_FIX__ExecInst", "FIX::ExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecInstValue = {"_p_FIX__ExecInstValue", "FIX::ExecInstValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecPriceAdjustment = {"_p_FIX__ExecPriceAdjustment", "FIX::ExecPriceAdjustment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecPriceType = {"_p_FIX__ExecPriceType", "FIX::ExecPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecRefID = {"_p_FIX__ExecRefID", "FIX::ExecRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecRestatementReason = {"_p_FIX__ExecRestatementReason", "FIX::ExecRestatementReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecTransType = {"_p_FIX__ExecTransType", "FIX::ExecTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecType = {"_p_FIX__ExecType", "FIX::ExecType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecValuationPoint = {"_p_FIX__ExecValuationPoint", "FIX::ExecValuationPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExerciseMethod = {"_p_FIX__ExerciseMethod", "FIX::ExerciseMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExerciseStyle = {"_p_FIX__ExerciseStyle", "FIX::ExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpQty = {"_p_FIX__ExpQty", "FIX::ExpQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpType = {"_p_FIX__ExpType", "FIX::ExpType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpirationCycle = {"_p_FIX__ExpirationCycle", "FIX::ExpirationCycle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpirationQtyType = {"_p_FIX__ExpirationQtyType", "FIX::ExpirationQtyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpireDate = {"_p_FIX__ExpireDate", "FIX::ExpireDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpireTime = {"_p_FIX__ExpireTime", "FIX::ExpireTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FLOAT = {"_p_FIX__FLOAT", "FIX::FLOAT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Factor = {"_p_FIX__Factor", "FIX::Factor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FairValue = {"_p_FIX__FairValue", "FIX::FairValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FeeMultiplier = {"_p_FIX__FeeMultiplier", "FIX::FeeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldBase = {"_p_FIX__FieldBase", "FIX::FieldBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldConvertError = {"_p_FIX__FieldConvertError", "FIX::FieldConvertError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap = {"_p_FIX__FieldMap", "FIX::FieldMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap__Fields__const_iterator = {"_p_FIX__FieldMap__Fields__const_iterator", "FIX::FieldMap::Fields::const_iterator *|FIX::FieldMap::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap__Groups__const_iterator = {"_p_FIX__FieldMap__Groups__const_iterator", "FIX::FieldMap::Groups::const_iterator *|FIX::FieldMap::g_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldNotFound = {"_p_FIX__FieldNotFound", "FIX::FieldNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileLog = {"_p_FIX__FileLog", "FIX::FileLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileLogFactory = {"_p_FIX__FileLogFactory", "FIX::FileLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileStore = {"_p_FIX__FileStore", "FIX::FileStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileStoreFactory = {"_p_FIX__FileStoreFactory", "FIX::FileStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillExecID = {"_p_FIX__FillExecID", "FIX::FillExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillLiquidityInd = {"_p_FIX__FillLiquidityInd", "FIX::FillLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillPx = {"_p_FIX__FillPx", "FIX::FillPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillQty = {"_p_FIX__FillQty", "FIX::FillQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FinancialStatus = {"_p_FIX__FinancialStatus", "FIX::FinancialStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FirmTradeID = {"_p_FIX__FirmTradeID", "FIX::FirmTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FirstPx = {"_p_FIX__FirstPx", "FIX::FirstPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlexProductEligibilityIndicator = {"_p_FIX__FlexProductEligibilityIndicator", "FIX::FlexProductEligibilityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlexibleIndicator = {"_p_FIX__FlexibleIndicator", "FIX::FlexibleIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FloorPrice = {"_p_FIX__FloorPrice", "FIX::FloorPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlowScheduleType = {"_p_FIX__FlowScheduleType", "FIX::FlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ForexReq = {"_p_FIX__ForexReq", "FIX::ForexReq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FundRenewWaiv = {"_p_FIX__FundRenewWaiv", "FIX::FundRenewWaiv *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FutSettDate = {"_p_FIX__FutSettDate", "FIX::FutSettDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FutSettDate2 = {"_p_FIX__FutSettDate2", "FIX::FutSettDate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FuturesValuationMethod = {"_p_FIX__FuturesValuationMethod", "FIX::FuturesValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GTBookingInst = {"_p_FIX__GTBookingInst", "FIX::GTBookingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GapFillFlag = {"_p_FIX__GapFillFlag", "FIX::GapFillFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GrossTradeAmt = {"_p_FIX__GrossTradeAmt", "FIX::GrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Group = {"_p_FIX__Group", "FIX::Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HaltReasonChar = {"_p_FIX__HaltReasonChar", "FIX::HaltReasonChar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HaltReasonInt = {"_p_FIX__HaltReasonInt", "FIX::HaltReasonInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HandlInst = {"_p_FIX__HandlInst", "FIX::HandlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Header = {"_p_FIX__Header", "FIX::Header *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Headline = {"_p_FIX__Headline", "FIX::Headline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HeartBtInt = {"_p_FIX__HeartBtInt", "FIX::HeartBtInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HighLimitPrice = {"_p_FIX__HighLimitPrice", "FIX::HighLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HighPx = {"_p_FIX__HighPx", "FIX::HighPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopCompID = {"_p_FIX__HopCompID", "FIX::HopCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopRefID = {"_p_FIX__HopRefID", "FIX::HopRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopSendingTime = {"_p_FIX__HopSendingTime", "FIX::HopSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HostCrossID = {"_p_FIX__HostCrossID", "FIX::HostCrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IDSource = {"_p_FIX__IDSource", "FIX::IDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__INT = {"_p_FIX__INT", "FIX::INT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOException = {"_p_FIX__IOException", "FIX::IOException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIID = {"_p_FIX__IOIID", "FIX::IOIID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOINaturalFlag = {"_p_FIX__IOINaturalFlag", "FIX::IOINaturalFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIOthSvc = {"_p_FIX__IOIOthSvc", "FIX::IOIOthSvc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQltyInd = {"_p_FIX__IOIQltyInd", "FIX::IOIQltyInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQty = {"_p_FIX__IOIQty", "FIX::IOIQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQualifier = {"_p_FIX__IOIQualifier", "FIX::IOIQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIRefID = {"_p_FIX__IOIRefID", "FIX::IOIRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIShares = {"_p_FIX__IOIShares", "FIX::IOIShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOITransType = {"_p_FIX__IOITransType", "FIX::IOITransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIid = {"_p_FIX__IOIid", "FIX::IOIid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ImpliedMarketIndicator = {"_p_FIX__ImpliedMarketIndicator", "FIX::ImpliedMarketIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InViewOfCommon = {"_p_FIX__InViewOfCommon", "FIX::InViewOfCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncTaxInd = {"_p_FIX__IncTaxInd", "FIX::IncTaxInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectDataFormat = {"_p_FIX__IncorrectDataFormat", "FIX::IncorrectDataFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectMessageStructure = {"_p_FIX__IncorrectMessageStructure", "FIX::IncorrectMessageStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectTagValue = {"_p_FIX__IncorrectTagValue", "FIX::IncorrectTagValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocID = {"_p_FIX__IndividualAllocID", "FIX::IndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocRejCode = {"_p_FIX__IndividualAllocRejCode", "FIX::IndividualAllocRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocType = {"_p_FIX__IndividualAllocType", "FIX::IndividualAllocType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Initiator = {"_p_FIX__Initiator", "FIX::Initiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InputSource = {"_p_FIX__InputSource", "FIX::InputSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrAttribType = {"_p_FIX__InstrAttribType", "FIX::InstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrAttribValue = {"_p_FIX__InstrAttribValue", "FIX::InstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrRegistry = {"_p_FIX__InstrRegistry", "FIX::InstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrmtAssignmentMethod = {"_p_FIX__InstrmtAssignmentMethod", "FIX::InstrmtAssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyID = {"_p_FIX__InstrumentPartyID", "FIX::InstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyIDSource = {"_p_FIX__InstrumentPartyIDSource", "FIX::InstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyRole = {"_p_FIX__InstrumentPartyRole", "FIX::InstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartySubID = {"_p_FIX__InstrumentPartySubID", "FIX::InstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartySubIDType = {"_p_FIX__InstrumentPartySubIDType", "FIX::InstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IntField = {"_p_FIX__IntField", "FIX::IntField *|FIX::LengthField *|FIX::NumInGroupField *|FIX::SeqNumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InterestAccrualDate = {"_p_FIX__InterestAccrualDate", "FIX::InterestAccrualDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InterestAtMaturity = {"_p_FIX__InterestAtMaturity", "FIX::InterestAtMaturity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidMessage = {"_p_FIX__InvalidMessage", "FIX::InvalidMessage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidMessageType = {"_p_FIX__InvalidMessageType", "FIX::InvalidMessageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidTagNumber = {"_p_FIX__InvalidTagNumber", "FIX::InvalidTagNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvestorCountryOfResidence = {"_p_FIX__InvestorCountryOfResidence", "FIX::InvestorCountryOfResidence *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IssueDate = {"_p_FIX__IssueDate", "FIX::IssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Issuer = {"_p_FIX__Issuer", "FIX::Issuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LANGUAGE = {"_p_FIX__LANGUAGE", "FIX::LANGUAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LENGTH = {"_p_FIX__LENGTH", "FIX::LENGTH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LOCALMKTDATE = {"_p_FIX__LOCALMKTDATE", "FIX::LOCALMKTDATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LanguageCode = {"_p_FIX__LanguageCode", "FIX::LanguageCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastCapacity = {"_p_FIX__LastCapacity", "FIX::LastCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastForwardPoints = {"_p_FIX__LastForwardPoints", "FIX::LastForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastForwardPoints2 = {"_p_FIX__LastForwardPoints2", "FIX::LastForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastFragment = {"_p_FIX__LastFragment", "FIX::LastFragment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastLiquidityInd = {"_p_FIX__LastLiquidityInd", "FIX::LastLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastMkt = {"_p_FIX__LastMkt", "FIX::LastMkt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastMsgSeqNumProcessed = {"_p_FIX__LastMsgSeqNumProcessed", "FIX::LastMsgSeqNumProcessed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastNetworkResponseID = {"_p_FIX__LastNetworkResponseID", "FIX::LastNetworkResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastParPx = {"_p_FIX__LastParPx", "FIX::LastParPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastPx = {"_p_FIX__LastPx", "FIX::LastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastQty = {"_p_FIX__LastQty", "FIX::LastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastRptRequested = {"_p_FIX__LastRptRequested", "FIX::LastRptRequested *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastShares = {"_p_FIX__LastShares", "FIX::LastShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastSpotRate = {"_p_FIX__LastSpotRate", "FIX::LastSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastSwapPoints = {"_p_FIX__LastSwapPoints", "FIX::LastSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastUpdateTime = {"_p_FIX__LastUpdateTime", "FIX::LastUpdateTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LateIndicator = {"_p_FIX__LateIndicator", "FIX::LateIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LeavesQty = {"_p_FIX__LeavesQty", "FIX::LeavesQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocAccount = {"_p_FIX__LegAllocAccount", "FIX::LegAllocAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocAcctIDSource = {"_p_FIX__LegAllocAcctIDSource", "FIX::LegAllocAcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocID = {"_p_FIX__LegAllocID", "FIX::LegAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocQty = {"_p_FIX__LegAllocQty", "FIX::LegAllocQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocSettlCurrency = {"_p_FIX__LegAllocSettlCurrency", "FIX::LegAllocSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurveCurrency = {"_p_FIX__LegBenchmarkCurveCurrency", "FIX::LegBenchmarkCurveCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurveName = {"_p_FIX__LegBenchmarkCurveName", "FIX::LegBenchmarkCurveName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurvePoint = {"_p_FIX__LegBenchmarkCurvePoint", "FIX::LegBenchmarkCurvePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkPrice = {"_p_FIX__LegBenchmarkPrice", "FIX::LegBenchmarkPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkPriceType = {"_p_FIX__LegBenchmarkPriceType", "FIX::LegBenchmarkPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBidForwardPoints = {"_p_FIX__LegBidForwardPoints", "FIX::LegBidForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBidPx = {"_p_FIX__LegBidPx", "FIX::LegBidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCFICode = {"_p_FIX__LegCFICode", "FIX::LegCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCalculatedCcyLastQty = {"_p_FIX__LegCalculatedCcyLastQty", "FIX::LegCalculatedCcyLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractMultiplier = {"_p_FIX__LegContractMultiplier", "FIX::LegContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractMultiplierUnit = {"_p_FIX__LegContractMultiplierUnit", "FIX::LegContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractSettlMonth = {"_p_FIX__LegContractSettlMonth", "FIX::LegContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCountryOfIssue = {"_p_FIX__LegCountryOfIssue", "FIX::LegCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCouponPaymentDate = {"_p_FIX__LegCouponPaymentDate", "FIX::LegCouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCouponRate = {"_p_FIX__LegCouponRate", "FIX::LegCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCoveredOrUncovered = {"_p_FIX__LegCoveredOrUncovered", "FIX::LegCoveredOrUncovered *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCreditRating = {"_p_FIX__LegCreditRating", "FIX::LegCreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCurrency = {"_p_FIX__LegCurrency", "FIX::LegCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCurrencyRatio = {"_p_FIX__LegCurrencyRatio", "FIX::LegCurrencyRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegDatedDate = {"_p_FIX__LegDatedDate", "FIX::LegDatedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegDividendYield = {"_p_FIX__LegDividendYield", "FIX::LegDividendYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegExecInst = {"_p_FIX__LegExecInst", "FIX::LegExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegExerciseStyle = {"_p_FIX__LegExerciseStyle", "FIX::LegExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFactor = {"_p_FIX__LegFactor", "FIX::LegFactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFlowScheduleType = {"_p_FIX__LegFlowScheduleType", "FIX::LegFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFutSettDate = {"_p_FIX__LegFutSettDate", "FIX::LegFutSettDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegGrossTradeAmt = {"_p_FIX__LegGrossTradeAmt", "FIX::LegGrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIOIQty = {"_p_FIX__LegIOIQty", "FIX::LegIOIQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIndividualAllocID = {"_p_FIX__LegIndividualAllocID", "FIX::LegIndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegInstrRegistry = {"_p_FIX__LegInstrRegistry", "FIX::LegInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegInterestAccrualDate = {"_p_FIX__LegInterestAccrualDate", "FIX::LegInterestAccrualDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIssueDate = {"_p_FIX__LegIssueDate", "FIX::LegIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIssuer = {"_p_FIX__LegIssuer", "FIX::LegIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastForwardPoints = {"_p_FIX__LegLastForwardPoints", "FIX::LegLastForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastPx = {"_p_FIX__LegLastPx", "FIX::LegLastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastQty = {"_p_FIX__LegLastQty", "FIX::LegLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLocaleOfIssue = {"_p_FIX__LegLocaleOfIssue", "FIX::LegLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityDate = {"_p_FIX__LegMaturityDate", "FIX::LegMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityMonthYear = {"_p_FIX__LegMaturityMonthYear", "FIX::LegMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityTime = {"_p_FIX__LegMaturityTime", "FIX::LegMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegNumber = {"_p_FIX__LegNumber", "FIX::LegNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOfferForwardPoints = {"_p_FIX__LegOfferForwardPoints", "FIX::LegOfferForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOfferPx = {"_p_FIX__LegOfferPx", "FIX::LegOfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOptAttribute = {"_p_FIX__LegOptAttribute", "FIX::LegOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOptionRatio = {"_p_FIX__LegOptionRatio", "FIX::LegOptionRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOrderQty = {"_p_FIX__LegOrderQty", "FIX::LegOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPool = {"_p_FIX__LegPool", "FIX::LegPool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPositionEffect = {"_p_FIX__LegPositionEffect", "FIX::LegPositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPrice = {"_p_FIX__LegPrice", "FIX::LegPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceType = {"_p_FIX__LegPriceType", "FIX::LegPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceUnitOfMeasure = {"_p_FIX__LegPriceUnitOfMeasure", "FIX::LegPriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceUnitOfMeasureQty = {"_p_FIX__LegPriceUnitOfMeasureQty", "FIX::LegPriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegProduct = {"_p_FIX__LegProduct", "FIX::LegProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPutOrCall = {"_p_FIX__LegPutOrCall", "FIX::LegPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegQty = {"_p_FIX__LegQty", "FIX::LegQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRatioQty = {"_p_FIX__LegRatioQty", "FIX::LegRatioQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRedemptionDate = {"_p_FIX__LegRedemptionDate", "FIX::LegRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRefID = {"_p_FIX__LegRefID", "FIX::LegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepoCollateralSecurityType = {"_p_FIX__LegRepoCollateralSecurityType", "FIX::LegRepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegReportID = {"_p_FIX__LegReportID", "FIX::LegReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepurchaseRate = {"_p_FIX__LegRepurchaseRate", "FIX::LegRepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepurchaseTerm = {"_p_FIX__LegRepurchaseTerm", "FIX::LegRepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityAltID = {"_p_FIX__LegSecurityAltID", "FIX::LegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityAltIDSource = {"_p_FIX__LegSecurityAltIDSource", "FIX::LegSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityDesc = {"_p_FIX__LegSecurityDesc", "FIX::LegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityExchange = {"_p_FIX__LegSecurityExchange", "FIX::LegSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityID = {"_p_FIX__LegSecurityID", "FIX::LegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityIDSource = {"_p_FIX__LegSecurityIDSource", "FIX::LegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecuritySubType = {"_p_FIX__LegSecuritySubType", "FIX::LegSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityType = {"_p_FIX__LegSecurityType", "FIX::LegSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlCurrency = {"_p_FIX__LegSettlCurrency", "FIX::LegSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlDate = {"_p_FIX__LegSettlDate", "FIX::LegSettlDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlType = {"_p_FIX__LegSettlType", "FIX::LegSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlmntTyp = {"_p_FIX__LegSettlmntTyp", "FIX::LegSettlmntTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSide = {"_p_FIX__LegSide", "FIX::LegSide *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStateOrProvinceOfIssue = {"_p_FIX__LegStateOrProvinceOfIssue", "FIX::LegStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStipulationType = {"_p_FIX__LegStipulationType", "FIX::LegStipulationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStipulationValue = {"_p_FIX__LegStipulationValue", "FIX::LegStipulationValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStrikeCurrency = {"_p_FIX__LegStrikeCurrency", "FIX::LegStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStrikePrice = {"_p_FIX__LegStrikePrice", "FIX::LegStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSwapType = {"_p_FIX__LegSwapType", "FIX::LegSwapType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSymbol = {"_p_FIX__LegSymbol", "FIX::LegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSymbolSfx = {"_p_FIX__LegSymbolSfx", "FIX::LegSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegTimeUnit = {"_p_FIX__LegTimeUnit", "FIX::LegTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegUnitOfMeasure = {"_p_FIX__LegUnitOfMeasure", "FIX::LegUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegUnitOfMeasureQty = {"_p_FIX__LegUnitOfMeasureQty", "FIX::LegUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegVolatility = {"_p_FIX__LegVolatility", "FIX::LegVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegalConfirm = {"_p_FIX__LegalConfirm", "FIX::LegalConfirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LinesOfText = {"_p_FIX__LinesOfText", "FIX::LinesOfText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityIndType = {"_p_FIX__LiquidityIndType", "FIX::LiquidityIndType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityNumSecurities = {"_p_FIX__LiquidityNumSecurities", "FIX::LiquidityNumSecurities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityPctHigh = {"_p_FIX__LiquidityPctHigh", "FIX::LiquidityPctHigh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityPctLow = {"_p_FIX__LiquidityPctLow", "FIX::LiquidityPctLow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityValue = {"_p_FIX__LiquidityValue", "FIX::LiquidityValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListExecInst = {"_p_FIX__ListExecInst", "FIX::ListExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListExecInstType = {"_p_FIX__ListExecInstType", "FIX::ListExecInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListID = {"_p_FIX__ListID", "FIX::ListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListMethod = {"_p_FIX__ListMethod", "FIX::ListMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListName = {"_p_FIX__ListName", "FIX::ListName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListNoOrds = {"_p_FIX__ListNoOrds", "FIX::ListNoOrds *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListOrderStatus = {"_p_FIX__ListOrderStatus", "FIX::ListOrderStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListRejectReason = {"_p_FIX__ListRejectReason", "FIX::ListRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListSeqNo = {"_p_FIX__ListSeqNo", "FIX::ListSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListStatusText = {"_p_FIX__ListStatusText", "FIX::ListStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListStatusType = {"_p_FIX__ListStatusType", "FIX::ListStatusType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListUpdateAction = {"_p_FIX__ListUpdateAction", "FIX::ListUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocaleOfIssue = {"_p_FIX__LocaleOfIssue", "FIX::LocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocateReqd = {"_p_FIX__LocateReqd", "FIX::LocateReqd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocationID = {"_p_FIX__LocationID", "FIX::LocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Log = {"_p_FIX__Log", "FIX::Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LogFactory = {"_p_FIX__LogFactory", "FIX::LogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LongQty = {"_p_FIX__LongQty", "FIX::LongQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LotType = {"_p_FIX__LotType", "FIX::LotType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LowLimitPrice = {"_p_FIX__LowLimitPrice", "FIX::LowLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LowPx = {"_p_FIX__LowPx", "FIX::LowPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDBookType = {"_p_FIX__MDBookType", "FIX::MDBookType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryBuyer = {"_p_FIX__MDEntryBuyer", "FIX::MDEntryBuyer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryDate = {"_p_FIX__MDEntryDate", "FIX::MDEntryDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryForwardPoints = {"_p_FIX__MDEntryForwardPoints", "FIX::MDEntryForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryID = {"_p_FIX__MDEntryID", "FIX::MDEntryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryOriginator = {"_p_FIX__MDEntryOriginator", "FIX::MDEntryOriginator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryPositionNo = {"_p_FIX__MDEntryPositionNo", "FIX::MDEntryPositionNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryPx = {"_p_FIX__MDEntryPx", "FIX::MDEntryPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryRefID = {"_p_FIX__MDEntryRefID", "FIX::MDEntryRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySeller = {"_p_FIX__MDEntrySeller", "FIX::MDEntrySeller *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySize = {"_p_FIX__MDEntrySize", "FIX::MDEntrySize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySpotRate = {"_p_FIX__MDEntrySpotRate", "FIX::MDEntrySpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryTime = {"_p_FIX__MDEntryTime", "FIX::MDEntryTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryType = {"_p_FIX__MDEntryType", "FIX::MDEntryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDFeedType = {"_p_FIX__MDFeedType", "FIX::MDFeedType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDImplicitDelete = {"_p_FIX__MDImplicitDelete", "FIX::MDImplicitDelete *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDMkt = {"_p_FIX__MDMkt", "FIX::MDMkt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDOriginType = {"_p_FIX__MDOriginType", "FIX::MDOriginType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDPriceLevel = {"_p_FIX__MDPriceLevel", "FIX::MDPriceLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDQuoteType = {"_p_FIX__MDQuoteType", "FIX::MDQuoteType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReportID = {"_p_FIX__MDReportID", "FIX::MDReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReqID = {"_p_FIX__MDReqID", "FIX::MDReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReqRejReason = {"_p_FIX__MDReqRejReason", "FIX::MDReqRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSecSize = {"_p_FIX__MDSecSize", "FIX::MDSecSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSecSizeType = {"_p_FIX__MDSecSizeType", "FIX::MDSecSizeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDStreamID = {"_p_FIX__MDStreamID", "FIX::MDStreamID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSubBookType = {"_p_FIX__MDSubBookType", "FIX::MDSubBookType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDUpdateAction = {"_p_FIX__MDUpdateAction", "FIX::MDUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDUpdateType = {"_p_FIX__MDUpdateType", "FIX::MDUpdateType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MONTHYEAR = {"_p_FIX__MONTHYEAR", "FIX::MONTHYEAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLECHARVALUE = {"_p_FIX__MULTIPLECHARVALUE", "FIX::MULTIPLECHARVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLESTRINGVALUE = {"_p_FIX__MULTIPLESTRINGVALUE", "FIX::MULTIPLESTRINGVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLEVALUESTRING = {"_p_FIX__MULTIPLEVALUESTRING", "FIX::MULTIPLEVALUESTRING *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MailingDtls = {"_p_FIX__MailingDtls", "FIX::MailingDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MailingInst = {"_p_FIX__MailingInst", "FIX::MailingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ManualOrderIndicator = {"_p_FIX__ManualOrderIndicator", "FIX::ManualOrderIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarginExcess = {"_p_FIX__MarginExcess", "FIX::MarginExcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarginRatio = {"_p_FIX__MarginRatio", "FIX::MarginRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketDepth = {"_p_FIX__MarketDepth", "FIX::MarketDepth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketID = {"_p_FIX__MarketID", "FIX::MarketID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketReportID = {"_p_FIX__MarketReportID", "FIX::MarketReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketReqID = {"_p_FIX__MarketReqID", "FIX::MarketReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketSegmentDesc = {"_p_FIX__MarketSegmentDesc", "FIX::MarketSegmentDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketSegmentID = {"_p_FIX__MarketSegmentID", "FIX::MarketSegmentID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketUpdateAction = {"_p_FIX__MarketUpdateAction", "FIX::MarketUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionRejectReason = {"_p_FIX__MassActionRejectReason", "FIX::MassActionRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionReportID = {"_p_FIX__MassActionReportID", "FIX::MassActionReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionResponse = {"_p_FIX__MassActionResponse", "FIX::MassActionResponse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionScope = {"_p_FIX__MassActionScope", "FIX::MassActionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionType = {"_p_FIX__MassActionType", "FIX::MassActionType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelRejectReason = {"_p_FIX__MassCancelRejectReason", "FIX::MassCancelRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelRequestType = {"_p_FIX__MassCancelRequestType", "FIX::MassCancelRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelResponse = {"_p_FIX__MassCancelResponse", "FIX::MassCancelResponse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassStatusReqID = {"_p_FIX__MassStatusReqID", "FIX::MassStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassStatusReqType = {"_p_FIX__MassStatusReqType", "FIX::MassStatusReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchAlgorithm = {"_p_FIX__MatchAlgorithm", "FIX::MatchAlgorithm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchIncrement = {"_p_FIX__MatchIncrement", "FIX::MatchIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchStatus = {"_p_FIX__MatchStatus", "FIX::MatchStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchType = {"_p_FIX__MatchType", "FIX::MatchType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityDate = {"_p_FIX__MaturityDate", "FIX::MaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityDay = {"_p_FIX__MaturityDay", "FIX::MaturityDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYear = {"_p_FIX__MaturityMonthYear", "FIX::MaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearFormat = {"_p_FIX__MaturityMonthYearFormat", "FIX::MaturityMonthYearFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearIncrement = {"_p_FIX__MaturityMonthYearIncrement", "FIX::MaturityMonthYearIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearIncrementUnits = {"_p_FIX__MaturityMonthYearIncrementUnits", "FIX::MaturityMonthYearIncrementUnits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityNetMoney = {"_p_FIX__MaturityNetMoney", "FIX::MaturityNetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityRuleID = {"_p_FIX__MaturityRuleID", "FIX::MaturityRuleID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityTime = {"_p_FIX__MaturityTime", "FIX::MaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxFloor = {"_p_FIX__MaxFloor", "FIX::MaxFloor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxMessageSize = {"_p_FIX__MaxMessageSize", "FIX::MaxMessageSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxPriceLevels = {"_p_FIX__MaxPriceLevels", "FIX::MaxPriceLevels *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxPriceVariation = {"_p_FIX__MaxPriceVariation", "FIX::MaxPriceVariation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxShow = {"_p_FIX__MaxShow", "FIX::MaxShow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxTradeVol = {"_p_FIX__MaxTradeVol", "FIX::MaxTradeVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MemoryStore = {"_p_FIX__MemoryStore", "FIX::MemoryStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MemoryStoreFactory = {"_p_FIX__MemoryStoreFactory", "FIX::MemoryStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Message = {"_p_FIX__Message", "FIX::Message *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageEncoding = {"_p_FIX__MessageEncoding", "FIX::MessageEncoding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageEventSource = {"_p_FIX__MessageEventSource", "FIX::MessageEventSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageParseError = {"_p_FIX__MessageParseError", "FIX::MessageParseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStore = {"_p_FIX__MessageStore", "FIX::MessageStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreExceptionWrapper = {"_p_FIX__MessageStoreExceptionWrapper", "FIX::MessageStoreExceptionWrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreFactory = {"_p_FIX__MessageStoreFactory", "FIX::MessageStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreFactoryExceptionWrapper = {"_p_FIX__MessageStoreFactoryExceptionWrapper", "FIX::MessageStoreFactoryExceptionWrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MidPx = {"_p_FIX__MidPx", "FIX::MidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MidYield = {"_p_FIX__MidYield", "FIX::MidYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinBidSize = {"_p_FIX__MinBidSize", "FIX::MinBidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinLotSize = {"_p_FIX__MinLotSize", "FIX::MinLotSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinOfferSize = {"_p_FIX__MinOfferSize", "FIX::MinOfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinPriceIncrement = {"_p_FIX__MinPriceIncrement", "FIX::MinPriceIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinPriceIncrementAmount = {"_p_FIX__MinPriceIncrementAmount", "FIX::MinPriceIncrementAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinQty = {"_p_FIX__MinQty", "FIX::MinQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinTradeVol = {"_p_FIX__MinTradeVol", "FIX::MinTradeVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeAmt = {"_p_FIX__MiscFeeAmt", "FIX::MiscFeeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeBasis = {"_p_FIX__MiscFeeBasis", "FIX::MiscFeeBasis *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeCurr = {"_p_FIX__MiscFeeCurr", "FIX::MiscFeeCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeType = {"_p_FIX__MiscFeeType", "FIX::MiscFeeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MktBidPx = {"_p_FIX__MktBidPx", "FIX::MktBidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MktOfferPx = {"_p_FIX__MktOfferPx", "FIX::MktOfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ModelType = {"_p_FIX__ModelType", "FIX::ModelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MoneyLaunderingStatus = {"_p_FIX__MoneyLaunderingStatus", "FIX::MoneyLaunderingStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgDirection = {"_p_FIX__MsgDirection", "FIX::MsgDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgSeqNum = {"_p_FIX__MsgSeqNum", "FIX::MsgSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgType = {"_p_FIX__MsgType", "FIX::MsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultiLegReportingType = {"_p_FIX__MultiLegReportingType", "FIX::MultiLegReportingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultiLegRptTypeReq = {"_p_FIX__MultiLegRptTypeReq", "FIX::MultiLegRptTypeReq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultilegModel = {"_p_FIX__MultilegModel", "FIX::MultilegModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultilegPriceMethod = {"_p_FIX__MultilegPriceMethod", "FIX::MultilegPriceMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NTPositionLimit = {"_p_FIX__NTPositionLimit", "FIX::NTPositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NUMINGROUP = {"_p_FIX__NUMINGROUP", "FIX::NUMINGROUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyID = {"_p_FIX__Nested2PartyID", "FIX::Nested2PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyIDSource = {"_p_FIX__Nested2PartyIDSource", "FIX::Nested2PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyRole = {"_p_FIX__Nested2PartyRole", "FIX::Nested2PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartySubID = {"_p_FIX__Nested2PartySubID", "FIX::Nested2PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartySubIDType = {"_p_FIX__Nested2PartySubIDType", "FIX::Nested2PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyID = {"_p_FIX__Nested3PartyID", "FIX::Nested3PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyIDSource = {"_p_FIX__Nested3PartyIDSource", "FIX::Nested3PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyRole = {"_p_FIX__Nested3PartyRole", "FIX::Nested3PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartySubID = {"_p_FIX__Nested3PartySubID", "FIX::Nested3PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartySubIDType = {"_p_FIX__Nested3PartySubIDType", "FIX::Nested3PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyID = {"_p_FIX__Nested4PartyID", "FIX::Nested4PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyIDSource = {"_p_FIX__Nested4PartyIDSource", "FIX::Nested4PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyRole = {"_p_FIX__Nested4PartyRole", "FIX::Nested4PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartySubID = {"_p_FIX__Nested4PartySubID", "FIX::Nested4PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartySubIDType = {"_p_FIX__Nested4PartySubIDType", "FIX::Nested4PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedInstrAttribType = {"_p_FIX__NestedInstrAttribType", "FIX::NestedInstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedInstrAttribValue = {"_p_FIX__NestedInstrAttribValue", "FIX::NestedInstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyID = {"_p_FIX__NestedPartyID", "FIX::NestedPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyIDSource = {"_p_FIX__NestedPartyIDSource", "FIX::NestedPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyRole = {"_p_FIX__NestedPartyRole", "FIX::NestedPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartySubID = {"_p_FIX__NestedPartySubID", "FIX::NestedPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartySubIDType = {"_p_FIX__NestedPartySubIDType", "FIX::NestedPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetChgPrevDay = {"_p_FIX__NetChgPrevDay", "FIX::NetChgPrevDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetGrossInd = {"_p_FIX__NetGrossInd", "FIX::NetGrossInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetMoney = {"_p_FIX__NetMoney", "FIX::NetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkRequestID = {"_p_FIX__NetworkRequestID", "FIX::NetworkRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkRequestType = {"_p_FIX__NetworkRequestType", "FIX::NetworkRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkResponseID = {"_p_FIX__NetworkResponseID", "FIX::NetworkResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkStatusResponseType = {"_p_FIX__NetworkStatusResponseType", "FIX::NetworkStatusResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewPassword = {"_p_FIX__NewPassword", "FIX::NewPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewSeqNo = {"_p_FIX__NewSeqNo", "FIX::NewSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsCategory = {"_p_FIX__NewsCategory", "FIX::NewsCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsID = {"_p_FIX__NewsID", "FIX::NewsID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsRefID = {"_p_FIX__NewsRefID", "FIX::NewsRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsRefType = {"_p_FIX__NewsRefType", "FIX::NewsRefType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NextExpectedMsgSeqNum = {"_p_FIX__NextExpectedMsgSeqNum", "FIX::NextExpectedMsgSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAffectedOrders = {"_p_FIX__NoAffectedOrders", "FIX::NoAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAllocs = {"_p_FIX__NoAllocs", "FIX::NoAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAltMDSource = {"_p_FIX__NoAltMDSource", "FIX::NoAltMDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoApplIDs = {"_p_FIX__NoApplIDs", "FIX::NoApplIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAsgnReqs = {"_p_FIX__NoAsgnReqs", "FIX::NoAsgnReqs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoBidComponents = {"_p_FIX__NoBidComponents", "FIX::NoBidComponents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoBidDescriptors = {"_p_FIX__NoBidDescriptors", "FIX::NoBidDescriptors *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCapacities = {"_p_FIX__NoCapacities", "FIX::NoCapacities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoClearingInstructions = {"_p_FIX__NoClearingInstructions", "FIX::NoClearingInstructions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCollInquiryQualifier = {"_p_FIX__NoCollInquiryQualifier", "FIX::NoCollInquiryQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCompIDs = {"_p_FIX__NoCompIDs", "FIX::NoCompIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEventDates = {"_p_FIX__NoComplexEventDates", "FIX::NoComplexEventDates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEventTimes = {"_p_FIX__NoComplexEventTimes", "FIX::NoComplexEventTimes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEvents = {"_p_FIX__NoComplexEvents", "FIX::NoComplexEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContAmts = {"_p_FIX__NoContAmts", "FIX::NoContAmts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContraBrokers = {"_p_FIX__NoContraBrokers", "FIX::NoContraBrokers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDates = {"_p_FIX__NoDates", "FIX::NoDates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeEvents = {"_p_FIX__NoDerivativeEvents", "FIX::NoDerivativeEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrAttrib = {"_p_FIX__NoDerivativeInstrAttrib", "FIX::NoDerivativeInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrumentParties = {"_p_FIX__NoDerivativeInstrumentParties", "FIX::NoDerivativeInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrumentPartySubIDs = {"_p_FIX__NoDerivativeInstrumentPartySubIDs", "FIX::NoDerivativeInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeSecurityAltID = {"_p_FIX__NoDerivativeSecurityAltID", "FIX::NoDerivativeSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDistribInsts = {"_p_FIX__NoDistribInsts", "FIX::NoDistribInsts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDlvyInst = {"_p_FIX__NoDlvyInst", "FIX::NoDlvyInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoEvents = {"_p_FIX__NoEvents", "FIX::NoEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExecInstRules = {"_p_FIX__NoExecInstRules", "FIX::NoExecInstRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExecs = {"_p_FIX__NoExecs", "FIX::NoExecs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExpiration = {"_p_FIX__NoExpiration", "FIX::NoExpiration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoFills = {"_p_FIX__NoFills", "FIX::NoFills *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoHops = {"_p_FIX__NoHops", "FIX::NoHops *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoIOIQualifiers = {"_p_FIX__NoIOIQualifiers", "FIX::NoIOIQualifiers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrAttrib = {"_p_FIX__NoInstrAttrib", "FIX::NoInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrumentParties = {"_p_FIX__NoInstrumentParties", "FIX::NoInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrumentPartySubIDs = {"_p_FIX__NoInstrumentPartySubIDs", "FIX::NoInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegAllocs = {"_p_FIX__NoLegAllocs", "FIX::NoLegAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegSecurityAltID = {"_p_FIX__NoLegSecurityAltID", "FIX::NoLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegStipulations = {"_p_FIX__NoLegStipulations", "FIX::NoLegStipulations *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegs = {"_p_FIX__NoLegs", "FIX::NoLegs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLinesOfText = {"_p_FIX__NoLinesOfText", "FIX::NoLinesOfText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLotTypeRules = {"_p_FIX__NoLotTypeRules", "FIX::NoLotTypeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDEntries = {"_p_FIX__NoMDEntries", "FIX::NoMDEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDEntryTypes = {"_p_FIX__NoMDEntryTypes", "FIX::NoMDEntryTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDFeedTypes = {"_p_FIX__NoMDFeedTypes", "FIX::NoMDFeedTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMarketSegments = {"_p_FIX__NoMarketSegments", "FIX::NoMarketSegments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMatchRules = {"_p_FIX__NoMatchRules", "FIX::NoMatchRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMaturityRules = {"_p_FIX__NoMaturityRules", "FIX::NoMaturityRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMiscFees = {"_p_FIX__NoMiscFees", "FIX::NoMiscFees *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMsgTypes = {"_p_FIX__NoMsgTypes", "FIX::NoMsgTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested2PartyIDs = {"_p_FIX__NoNested2PartyIDs", "FIX::NoNested2PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested2PartySubIDs = {"_p_FIX__NoNested2PartySubIDs", "FIX::NoNested2PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested3PartyIDs = {"_p_FIX__NoNested3PartyIDs", "FIX::NoNested3PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested3PartySubIDs = {"_p_FIX__NoNested3PartySubIDs", "FIX::NoNested3PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested4PartyIDs = {"_p_FIX__NoNested4PartyIDs", "FIX::NoNested4PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested4PartySubIDs = {"_p_FIX__NoNested4PartySubIDs", "FIX::NoNested4PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedInstrAttrib = {"_p_FIX__NoNestedInstrAttrib", "FIX::NoNestedInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedPartyIDs = {"_p_FIX__NoNestedPartyIDs", "FIX::NoNestedPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedPartySubIDs = {"_p_FIX__NoNestedPartySubIDs", "FIX::NoNestedPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNewsRefIDs = {"_p_FIX__NoNewsRefIDs", "FIX::NoNewsRefIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNotAffectedOrders = {"_p_FIX__NoNotAffectedOrders", "FIX::NoNotAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOfLegUnderlyings = {"_p_FIX__NoOfLegUnderlyings", "FIX::NoOfLegUnderlyings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOfSecSizes = {"_p_FIX__NoOfSecSizes", "FIX::NoOfSecSizes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOrdTypeRules = {"_p_FIX__NoOrdTypeRules", "FIX::NoOrdTypeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOrders = {"_p_FIX__NoOrders", "FIX::NoOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyIDs = {"_p_FIX__NoPartyIDs", "FIX::NoPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartySubIDs = {"_p_FIX__NoPartySubIDs", "FIX::NoPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPosAmt = {"_p_FIX__NoPosAmt", "FIX::NoPosAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPositions = {"_p_FIX__NoPositions", "FIX::NoPositions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteEntries = {"_p_FIX__NoQuoteEntries", "FIX::NoQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteQualifiers = {"_p_FIX__NoQuoteQualifiers", "FIX::NoQuoteQualifiers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteSets = {"_p_FIX__NoQuoteSets", "FIX::NoQuoteSets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRateSources = {"_p_FIX__NoRateSources", "FIX::NoRateSources *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRegistDtls = {"_p_FIX__NoRegistDtls", "FIX::NoRegistDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedSym = {"_p_FIX__NoRelatedSym", "FIX::NoRelatedSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRootPartyIDs = {"_p_FIX__NoRootPartyIDs", "FIX::NoRootPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRootPartySubIDs = {"_p_FIX__NoRootPartySubIDs", "FIX::NoRootPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRoutingIDs = {"_p_FIX__NoRoutingIDs", "FIX::NoRoutingIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRpts = {"_p_FIX__NoRpts", "FIX::NoRpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSecurityAltID = {"_p_FIX__NoSecurityAltID", "FIX::NoSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSecurityTypes = {"_p_FIX__NoSecurityTypes", "FIX::NoSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlDetails = {"_p_FIX__NoSettlDetails", "FIX::NoSettlDetails *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlInst = {"_p_FIX__NoSettlInst", "FIX::NoSettlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlOblig = {"_p_FIX__NoSettlOblig", "FIX::NoSettlOblig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlPartyIDs = {"_p_FIX__NoSettlPartyIDs", "FIX::NoSettlPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlPartySubIDs = {"_p_FIX__NoSettlPartySubIDs", "FIX::NoSettlPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSideTrdRegTS = {"_p_FIX__NoSideTrdRegTS", "FIX::NoSideTrdRegTS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSides = {"_p_FIX__NoSides", "FIX::NoSides *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStatsIndicators = {"_p_FIX__NoStatsIndicators", "FIX::NoStatsIndicators *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStipulations = {"_p_FIX__NoStipulations", "FIX::NoStipulations *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrategyParameters = {"_p_FIX__NoStrategyParameters", "FIX::NoStrategyParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrikeRules = {"_p_FIX__NoStrikeRules", "FIX::NoStrikeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrikes = {"_p_FIX__NoStrikes", "FIX::NoStrikes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTagValue = {"_p_FIX__NoTagValue", "FIX::NoTagValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTargetPartyIDs = {"_p_FIX__NoTargetPartyIDs", "FIX::NoTargetPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTickRules = {"_p_FIX__NoTickRules", "FIX::NoTickRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTimeInForceRules = {"_p_FIX__NoTimeInForceRules", "FIX::NoTimeInForceRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrades = {"_p_FIX__NoTrades", "FIX::NoTrades *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTradingSessionRules = {"_p_FIX__NoTradingSessionRules", "FIX::NoTradingSessionRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTradingSessions = {"_p_FIX__NoTradingSessions", "FIX::NoTradingSessions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrdRegTimestamps = {"_p_FIX__NoTrdRegTimestamps", "FIX::NoTrdRegTimestamps *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrdRepIndicators = {"_p_FIX__NoTrdRepIndicators", "FIX::NoTrdRepIndicators *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingAmounts = {"_p_FIX__NoUnderlyingAmounts", "FIX::NoUnderlyingAmounts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingLegSecurityAltID = {"_p_FIX__NoUnderlyingLegSecurityAltID", "FIX::NoUnderlyingLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingSecurityAltID = {"_p_FIX__NoUnderlyingSecurityAltID", "FIX::NoUnderlyingSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingStips = {"_p_FIX__NoUnderlyingStips", "FIX::NoUnderlyingStips *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyings = {"_p_FIX__NoUnderlyings", "FIX::NoUnderlyings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUndlyInstrumentParties = {"_p_FIX__NoUndlyInstrumentParties", "FIX::NoUndlyInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUndlyInstrumentPartySubIDs = {"_p_FIX__NoUndlyInstrumentPartySubIDs", "FIX::NoUndlyInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotAffOrigClOrdID = {"_p_FIX__NotAffOrigClOrdID", "FIX::NotAffOrigClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotAffectedOrderID = {"_p_FIX__NotAffectedOrderID", "FIX::NotAffectedOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotifyBrokerOfCredit = {"_p_FIX__NotifyBrokerOfCredit", "FIX::NotifyBrokerOfCredit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotionalPercentageOutstanding = {"_p_FIX__NotionalPercentageOutstanding", "FIX::NotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullApplication = {"_p_FIX__NullApplication", "FIX::NullApplication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullLog = {"_p_FIX__NullLog", "FIX::NullLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumBidders = {"_p_FIX__NumBidders", "FIX::NumBidders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumDaysInterest = {"_p_FIX__NumDaysInterest", "FIX::NumDaysInterest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumTickets = {"_p_FIX__NumTickets", "FIX::NumTickets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumberOfOrders = {"_p_FIX__NumberOfOrders", "FIX::NumberOfOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OddLot = {"_p_FIX__OddLot", "FIX::OddLot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferForwardPoints = {"_p_FIX__OfferForwardPoints", "FIX::OfferForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferForwardPoints2 = {"_p_FIX__OfferForwardPoints2", "FIX::OfferForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferPx = {"_p_FIX__OfferPx", "FIX::OfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSize = {"_p_FIX__OfferSize", "FIX::OfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSpotRate = {"_p_FIX__OfferSpotRate", "FIX::OfferSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSwapPoints = {"_p_FIX__OfferSwapPoints", "FIX::OfferSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferYield = {"_p_FIX__OfferYield", "FIX::OfferYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfCompID = {"_p_FIX__OnBehalfOfCompID", "FIX::OnBehalfOfCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfLocationID = {"_p_FIX__OnBehalfOfLocationID", "FIX::OnBehalfOfLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfSendingTime = {"_p_FIX__OnBehalfOfSendingTime", "FIX::OnBehalfOfSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfSubID = {"_p_FIX__OnBehalfOfSubID", "FIX::OnBehalfOfSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenClose = {"_p_FIX__OpenClose", "FIX::OpenClose *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenCloseSettlFlag = {"_p_FIX__OpenCloseSettlFlag", "FIX::OpenCloseSettlFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenCloseSettleFlag = {"_p_FIX__OpenCloseSettleFlag", "FIX::OpenCloseSettleFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenInterest = {"_p_FIX__OpenInterest", "FIX::OpenInterest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptAttribute = {"_p_FIX__OptAttribute", "FIX::OptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayAmount = {"_p_FIX__OptPayAmount", "FIX::OptPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayoutAmount = {"_p_FIX__OptPayoutAmount", "FIX::OptPayoutAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayoutType = {"_p_FIX__OptPayoutType", "FIX::OptPayoutType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdRejReason = {"_p_FIX__OrdRejReason", "FIX::OrdRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdStatus = {"_p_FIX__OrdStatus", "FIX::OrdStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdStatusReqID = {"_p_FIX__OrdStatusReqID", "FIX::OrdStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdType = {"_p_FIX__OrdType", "FIX::OrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderAvgPx = {"_p_FIX__OrderAvgPx", "FIX::OrderAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderBookingQty = {"_p_FIX__OrderBookingQty", "FIX::OrderBookingQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCapacity = {"_p_FIX__OrderCapacity", "FIX::OrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCapacityQty = {"_p_FIX__OrderCapacityQty", "FIX::OrderCapacityQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCategory = {"_p_FIX__OrderCategory", "FIX::OrderCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderDelay = {"_p_FIX__OrderDelay", "FIX::OrderDelay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderDelayUnit = {"_p_FIX__OrderDelayUnit", "FIX::OrderDelayUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderHandlingInstSource = {"_p_FIX__OrderHandlingInstSource", "FIX::OrderHandlingInstSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderID = {"_p_FIX__OrderID", "FIX::OrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderInputDevice = {"_p_FIX__OrderInputDevice", "FIX::OrderInputDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderPercent = {"_p_FIX__OrderPercent", "FIX::OrderPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderQty = {"_p_FIX__OrderQty", "FIX::OrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderQty2 = {"_p_FIX__OrderQty2", "FIX::OrderQty2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderRestrictions = {"_p_FIX__OrderRestrictions", "FIX::OrderRestrictions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigClOrdID = {"_p_FIX__OrigClOrdID", "FIX::OrigClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigCrossID = {"_p_FIX__OrigCrossID", "FIX::OrigCrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigCustOrderCapacity = {"_p_FIX__OrigCustOrderCapacity", "FIX::OrigCustOrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigOrdModTime = {"_p_FIX__OrigOrdModTime", "FIX::OrigOrdModTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigPosReqRefID = {"_p_FIX__OrigPosReqRefID", "FIX::OrigPosReqRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigSecondaryTradeID = {"_p_FIX__OrigSecondaryTradeID", "FIX::OrigSecondaryTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigSendingTime = {"_p_FIX__OrigSendingTime", "FIX::OrigSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTime = {"_p_FIX__OrigTime", "FIX::OrigTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeDate = {"_p_FIX__OrigTradeDate", "FIX::OrigTradeDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeHandlingInstr = {"_p_FIX__OrigTradeHandlingInstr", "FIX::OrigTradeHandlingInstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeID = {"_p_FIX__OrigTradeID", "FIX::OrigTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OriginalNotionalPercentageOutstanding = {"_p_FIX__OriginalNotionalPercentageOutstanding", "FIX::OriginalNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OutMainCntryUIndex = {"_p_FIX__OutMainCntryUIndex", "FIX::OutMainCntryUIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OutsideIndexPct = {"_p_FIX__OutsideIndexPct", "FIX::OutsideIndexPct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OwnerType = {"_p_FIX__OwnerType", "FIX::OwnerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OwnershipType = {"_p_FIX__OwnershipType", "FIX::OwnershipType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PERCENTAGE = {"_p_FIX__PERCENTAGE", "FIX::PERCENTAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PRICE = {"_p_FIX__PRICE", "FIX::PRICE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PRICEOFFSET = {"_p_FIX__PRICEOFFSET", "FIX::PRICEOFFSET *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ParentMktSegmID = {"_p_FIX__ParentMktSegmID", "FIX::ParentMktSegmID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ParticipationRate = {"_p_FIX__ParticipationRate", "FIX::ParticipationRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyID = {"_p_FIX__PartyID", "FIX::PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyIDSource = {"_p_FIX__PartyIDSource", "FIX::PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyRole = {"_p_FIX__PartyRole", "FIX::PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartySubID = {"_p_FIX__PartySubID", "FIX::PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartySubIDType = {"_p_FIX__PartySubIDType", "FIX::PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Password = {"_p_FIX__Password", "FIX::Password *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentDate = {"_p_FIX__PaymentDate", "FIX::PaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentMethod = {"_p_FIX__PaymentMethod", "FIX::PaymentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentRef = {"_p_FIX__PaymentRef", "FIX::PaymentRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentRemitterID = {"_p_FIX__PaymentRemitterID", "FIX::PaymentRemitterID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PctAtRisk = {"_p_FIX__PctAtRisk", "FIX::PctAtRisk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegDifference = {"_p_FIX__PegDifference", "FIX::PegDifference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegLimitType = {"_p_FIX__PegLimitType", "FIX::PegLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegMoveType = {"_p_FIX__PegMoveType", "FIX::PegMoveType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegOffsetType = {"_p_FIX__PegOffsetType", "FIX::PegOffsetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegOffsetValue = {"_p_FIX__PegOffsetValue", "FIX::PegOffsetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegPriceType = {"_p_FIX__PegPriceType", "FIX::PegPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegRoundDirection = {"_p_FIX__PegRoundDirection", "FIX::PegRoundDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegScope = {"_p_FIX__PegScope", "FIX::PegScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityDesc = {"_p_FIX__PegSecurityDesc", "FIX::PegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityID = {"_p_FIX__PegSecurityID", "FIX::PegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityIDSource = {"_p_FIX__PegSecurityIDSource", "FIX::PegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSymbol = {"_p_FIX__PegSymbol", "FIX::PegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PeggedPrice = {"_p_FIX__PeggedPrice", "FIX::PeggedPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PeggedRefPrice = {"_p_FIX__PeggedRefPrice", "FIX::PeggedRefPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Pool = {"_p_FIX__Pool", "FIX::Pool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosAmt = {"_p_FIX__PosAmt", "FIX::PosAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosAmtType = {"_p_FIX__PosAmtType", "FIX::PosAmtType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintAction = {"_p_FIX__PosMaintAction", "FIX::PosMaintAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintResult = {"_p_FIX__PosMaintResult", "FIX::PosMaintResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintRptID = {"_p_FIX__PosMaintRptID", "FIX::PosMaintRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintRptRefID = {"_p_FIX__PosMaintRptRefID", "FIX::PosMaintRptRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintStatus = {"_p_FIX__PosMaintStatus", "FIX::PosMaintStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosQtyStatus = {"_p_FIX__PosQtyStatus", "FIX::PosQtyStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqID = {"_p_FIX__PosReqID", "FIX::PosReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqResult = {"_p_FIX__PosReqResult", "FIX::PosReqResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqStatus = {"_p_FIX__PosReqStatus", "FIX::PosReqStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqType = {"_p_FIX__PosReqType", "FIX::PosReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosTransType = {"_p_FIX__PosTransType", "FIX::PosTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosType = {"_p_FIX__PosType", "FIX::PosType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionCurrency = {"_p_FIX__PositionCurrency", "FIX::PositionCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionEffect = {"_p_FIX__PositionEffect", "FIX::PositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionLimit = {"_p_FIX__PositionLimit", "FIX::PositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PossDupFlag = {"_p_FIX__PossDupFlag", "FIX::PossDupFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PossResend = {"_p_FIX__PossResend", "FIX::PossResend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreTradeAnonymity = {"_p_FIX__PreTradeAnonymity", "FIX::PreTradeAnonymity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreallocMethod = {"_p_FIX__PreallocMethod", "FIX::PreallocMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PrevClosePx = {"_p_FIX__PrevClosePx", "FIX::PrevClosePx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreviouslyReported = {"_p_FIX__PreviouslyReported", "FIX::PreviouslyReported *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Price = {"_p_FIX__Price", "FIX::Price *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Price2 = {"_p_FIX__Price2", "FIX::Price2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceDelta = {"_p_FIX__PriceDelta", "FIX::PriceDelta *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceImprovement = {"_p_FIX__PriceImprovement", "FIX::PriceImprovement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceLimitType = {"_p_FIX__PriceLimitType", "FIX::PriceLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceProtectionScope = {"_p_FIX__PriceProtectionScope", "FIX::PriceProtectionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceQuoteMethod = {"_p_FIX__PriceQuoteMethod", "FIX::PriceQuoteMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceType = {"_p_FIX__PriceType", "FIX::PriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceUnitOfMeasure = {"_p_FIX__PriceUnitOfMeasure", "FIX::PriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceUnitOfMeasureQty = {"_p_FIX__PriceUnitOfMeasureQty", "FIX::PriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorSettlPrice = {"_p_FIX__PriorSettlPrice", "FIX::PriorSettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorSpreadIndicator = {"_p_FIX__PriorSpreadIndicator", "FIX::PriorSpreadIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorityIndicator = {"_p_FIX__PriorityIndicator", "FIX::PriorityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PrivateQuote = {"_p_FIX__PrivateQuote", "FIX::PrivateQuote *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProcessCode = {"_p_FIX__ProcessCode", "FIX::ProcessCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Product = {"_p_FIX__Product", "FIX::Product *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProductComplex = {"_p_FIX__ProductComplex", "FIX::ProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProgPeriodInterval = {"_p_FIX__ProgPeriodInterval", "FIX::ProgPeriodInterval *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProgRptReqs = {"_p_FIX__ProgRptReqs", "FIX::ProgRptReqs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PublishTrdIndicator = {"_p_FIX__PublishTrdIndicator", "FIX::PublishTrdIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PutOrCall = {"_p_FIX__PutOrCall", "FIX::PutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QTY = {"_p_FIX__QTY", "FIX::QTY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QtyType = {"_p_FIX__QtyType", "FIX::QtyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Quantity = {"_p_FIX__Quantity", "FIX::Quantity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuantityDate = {"_p_FIX__QuantityDate", "FIX::QuantityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuantityType = {"_p_FIX__QuantityType", "FIX::QuantityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteAckStatus = {"_p_FIX__QuoteAckStatus", "FIX::QuoteAckStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteCancelType = {"_p_FIX__QuoteCancelType", "FIX::QuoteCancelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteCondition = {"_p_FIX__QuoteCondition", "FIX::QuoteCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryID = {"_p_FIX__QuoteEntryID", "FIX::QuoteEntryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryRejectReason = {"_p_FIX__QuoteEntryRejectReason", "FIX::QuoteEntryRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryStatus = {"_p_FIX__QuoteEntryStatus", "FIX::QuoteEntryStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteID = {"_p_FIX__QuoteID", "FIX::QuoteID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteMsgID = {"_p_FIX__QuoteMsgID", "FIX::QuoteMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuotePriceType = {"_p_FIX__QuotePriceType", "FIX::QuotePriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteQualifier = {"_p_FIX__QuoteQualifier", "FIX::QuoteQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRejectReason = {"_p_FIX__QuoteRejectReason", "FIX::QuoteRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteReqID = {"_p_FIX__QuoteReqID", "FIX::QuoteReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRequestRejectReason = {"_p_FIX__QuoteRequestRejectReason", "FIX::QuoteRequestRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRequestType = {"_p_FIX__QuoteRequestType", "FIX::QuoteRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRespID = {"_p_FIX__QuoteRespID", "FIX::QuoteRespID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRespType = {"_p_FIX__QuoteRespType", "FIX::QuoteRespType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteResponseLevel = {"_p_FIX__QuoteResponseLevel", "FIX::QuoteResponseLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteSetID = {"_p_FIX__QuoteSetID", "FIX::QuoteSetID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteSetValidUntilTime = {"_p_FIX__QuoteSetValidUntilTime", "FIX::QuoteSetValidUntilTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteStatus = {"_p_FIX__QuoteStatus", "FIX::QuoteStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteStatusReqID = {"_p_FIX__QuoteStatusReqID", "FIX::QuoteStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteType = {"_p_FIX__QuoteType", "FIX::QuoteType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RFQReqID = {"_p_FIX__RFQReqID", "FIX::RFQReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RateSource = {"_p_FIX__RateSource", "FIX::RateSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RateSourceType = {"_p_FIX__RateSourceType", "FIX::RateSourceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RatioQty = {"_p_FIX__RatioQty", "FIX::RatioQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RawData = {"_p_FIX__RawData", "FIX::RawData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RawDataLength = {"_p_FIX__RawDataLength", "FIX::RawDataLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReceivedDeptID = {"_p_FIX__ReceivedDeptID", "FIX::ReceivedDeptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RedemptionDate = {"_p_FIX__RedemptionDate", "FIX::RedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefAllocID = {"_p_FIX__RefAllocID", "FIX::RefAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplExtID = {"_p_FIX__RefApplExtID", "FIX::RefApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplID = {"_p_FIX__RefApplID", "FIX::RefApplID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplLastSeqNum = {"_p_FIX__RefApplLastSeqNum", "FIX::RefApplLastSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplReqID = {"_p_FIX__RefApplReqID", "FIX::RefApplReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplVerID = {"_p_FIX__RefApplVerID", "FIX::RefApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefCompID = {"_p_FIX__RefCompID", "FIX::RefCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefCstmApplVerID = {"_p_FIX__RefCstmApplVerID", "FIX::RefCstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefMsgType = {"_p_FIX__RefMsgType", "FIX::RefMsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrdIDReason = {"_p_FIX__RefOrdIDReason", "FIX::RefOrdIDReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrderID = {"_p_FIX__RefOrderID", "FIX::RefOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrderIDSource = {"_p_FIX__RefOrderIDSource", "FIX::RefOrderIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefSeqNum = {"_p_FIX__RefSeqNum", "FIX::RefSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefSubID = {"_p_FIX__RefSubID", "FIX::RefSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefTagID = {"_p_FIX__RefTagID", "FIX::RefTagID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReferencePage = {"_p_FIX__ReferencePage", "FIX::ReferencePage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefreshIndicator = {"_p_FIX__RefreshIndicator", "FIX::RefreshIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefreshQty = {"_p_FIX__RefreshQty", "FIX::RefreshQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistAcctType = {"_p_FIX__RegistAcctType", "FIX::RegistAcctType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistDetls = {"_p_FIX__RegistDetls", "FIX::RegistDetls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistDtls = {"_p_FIX__RegistDtls", "FIX::RegistDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistEmail = {"_p_FIX__RegistEmail", "FIX::RegistEmail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistID = {"_p_FIX__RegistID", "FIX::RegistID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRefID = {"_p_FIX__RegistRefID", "FIX::RegistRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRejReasonCode = {"_p_FIX__RegistRejReasonCode", "FIX::RegistRejReasonCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRejReasonText = {"_p_FIX__RegistRejReasonText", "FIX::RegistRejReasonText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistStatus = {"_p_FIX__RegistStatus", "FIX::RegistStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistTransType = {"_p_FIX__RegistTransType", "FIX::RegistTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RejectLogon = {"_p_FIX__RejectLogon", "FIX::RejectLogon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RejectText = {"_p_FIX__RejectText", "FIX::RejectText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelSymTransactTime = {"_p_FIX__RelSymTransactTime", "FIX::RelSymTransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatdSym = {"_p_FIX__RelatdSym", "FIX::RelatdSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepeatedTag = {"_p_FIX__RepeatedTag", "FIX::RepeatedTag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepeatingGroupCountMismatch = {"_p_FIX__RepeatingGroupCountMismatch", "FIX::RepeatingGroupCountMismatch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepoCollateralSecurityType = {"_p_FIX__RepoCollateralSecurityType", "FIX::RepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportToExch = {"_p_FIX__ReportToExch", "FIX::ReportToExch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportedPx = {"_p_FIX__ReportedPx", "FIX::ReportedPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportedPxDiff = {"_p_FIX__ReportedPxDiff", "FIX::ReportedPxDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepurchaseRate = {"_p_FIX__RepurchaseRate", "FIX::RepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepurchaseTerm = {"_p_FIX__RepurchaseTerm", "FIX::RepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RequiredTagMissing = {"_p_FIX__RequiredTagMissing", "FIX::RequiredTagMissing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResetSeqNumFlag = {"_p_FIX__ResetSeqNumFlag", "FIX::ResetSeqNumFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RespondentType = {"_p_FIX__RespondentType", "FIX::RespondentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResponseDestination = {"_p_FIX__ResponseDestination", "FIX::ResponseDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResponseTransportType = {"_p_FIX__ResponseTransportType", "FIX::ResponseTransportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RestructuringType = {"_p_FIX__RestructuringType", "FIX::RestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReversalIndicator = {"_p_FIX__ReversalIndicator", "FIX::ReversalIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskFreeRate = {"_p_FIX__RiskFreeRate", "FIX::RiskFreeRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RndPx = {"_p_FIX__RndPx", "FIX::RndPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyID = {"_p_FIX__RootPartyID", "FIX::RootPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyIDSource = {"_p_FIX__RootPartyIDSource", "FIX::RootPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyRole = {"_p_FIX__RootPartyRole", "FIX::RootPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartySubID = {"_p_FIX__RootPartySubID", "FIX::RootPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartySubIDType = {"_p_FIX__RootPartySubIDType", "FIX::RootPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundLot = {"_p_FIX__RoundLot", "FIX::RoundLot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundingDirection = {"_p_FIX__RoundingDirection", "FIX::RoundingDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundingModulus = {"_p_FIX__RoundingModulus", "FIX::RoundingModulus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoutingID = {"_p_FIX__RoutingID", "FIX::RoutingID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoutingType = {"_p_FIX__RoutingType", "FIX::RoutingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RptSeq = {"_p_FIX__RptSeq", "FIX::RptSeq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RptSys = {"_p_FIX__RptSys", "FIX::RptSys *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Rule80A = {"_p_FIX__Rule80A", "FIX::Rule80A *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RuntimeError = {"_p_FIX__RuntimeError", "FIX::RuntimeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SEQNUM = {"_p_FIX__SEQNUM", "FIX::SEQNUM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__STRING = {"_p_FIX__STRING", "FIX::STRING *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Scope = {"_p_FIX__Scope", "FIX::Scope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ScreenLog = {"_p_FIX__ScreenLog", "FIX::ScreenLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ScreenLogFactory = {"_p_FIX__ScreenLogFactory", "FIX::ScreenLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryAllocID = {"_p_FIX__SecondaryAllocID", "FIX::SecondaryAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryClOrdID = {"_p_FIX__SecondaryClOrdID", "FIX::SecondaryClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryDisplayQty = {"_p_FIX__SecondaryDisplayQty", "FIX::SecondaryDisplayQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryExecID = {"_p_FIX__SecondaryExecID", "FIX::SecondaryExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryFirmTradeID = {"_p_FIX__SecondaryFirmTradeID", "FIX::SecondaryFirmTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryHighLimitPrice = {"_p_FIX__SecondaryHighLimitPrice", "FIX::SecondaryHighLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryIndividualAllocID = {"_p_FIX__SecondaryIndividualAllocID", "FIX::SecondaryIndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryLowLimitPrice = {"_p_FIX__SecondaryLowLimitPrice", "FIX::SecondaryLowLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryOrderID = {"_p_FIX__SecondaryOrderID", "FIX::SecondaryOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryPriceLimitType = {"_p_FIX__SecondaryPriceLimitType", "FIX::SecondaryPriceLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeID = {"_p_FIX__SecondaryTradeID", "FIX::SecondaryTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeReportID = {"_p_FIX__SecondaryTradeReportID", "FIX::SecondaryTradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeReportRefID = {"_p_FIX__SecondaryTradeReportRefID", "FIX::SecondaryTradeReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradingReferencePrice = {"_p_FIX__SecondaryTradingReferencePrice", "FIX::SecondaryTradingReferencePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTrdType = {"_p_FIX__SecondaryTrdType", "FIX::SecondaryTrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecureData = {"_p_FIX__SecureData", "FIX::SecureData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecureDataLen = {"_p_FIX__SecureDataLen", "FIX::SecureDataLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityAltID = {"_p_FIX__SecurityAltID", "FIX::SecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityAltIDSource = {"_p_FIX__SecurityAltIDSource", "FIX::SecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityDesc = {"_p_FIX__SecurityDesc", "FIX::SecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityExchange = {"_p_FIX__SecurityExchange", "FIX::SecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityGroup = {"_p_FIX__SecurityGroup", "FIX::SecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityID = {"_p_FIX__SecurityID", "FIX::SecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityIDSource = {"_p_FIX__SecurityIDSource", "FIX::SecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListDesc = {"_p_FIX__SecurityListDesc", "FIX::SecurityListDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListID = {"_p_FIX__SecurityListID", "FIX::SecurityListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListRefID = {"_p_FIX__SecurityListRefID", "FIX::SecurityListRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListRequestType = {"_p_FIX__SecurityListRequestType", "FIX::SecurityListRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListType = {"_p_FIX__SecurityListType", "FIX::SecurityListType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListTypeSource = {"_p_FIX__SecurityListTypeSource", "FIX::SecurityListTypeSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityReportID = {"_p_FIX__SecurityReportID", "FIX::SecurityReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityReqID = {"_p_FIX__SecurityReqID", "FIX::SecurityReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityRequestResult = {"_p_FIX__SecurityRequestResult", "FIX::SecurityRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityRequestType = {"_p_FIX__SecurityRequestType", "FIX::SecurityRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityResponseID = {"_p_FIX__SecurityResponseID", "FIX::SecurityResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityResponseType = {"_p_FIX__SecurityResponseType", "FIX::SecurityResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentAcctName = {"_p_FIX__SecuritySettlAgentAcctName", "FIX::SecuritySettlAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentAcctNum = {"_p_FIX__SecuritySettlAgentAcctNum", "FIX::SecuritySettlAgentAcctNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentCode = {"_p_FIX__SecuritySettlAgentCode", "FIX::SecuritySettlAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentContactName = {"_p_FIX__SecuritySettlAgentContactName", "FIX::SecuritySettlAgentContactName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentContactPhone = {"_p_FIX__SecuritySettlAgentContactPhone", "FIX::SecuritySettlAgentContactPhone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentName = {"_p_FIX__SecuritySettlAgentName", "FIX::SecuritySettlAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityStatus = {"_p_FIX__SecurityStatus", "FIX::SecurityStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityStatusReqID = {"_p_FIX__SecurityStatusReqID", "FIX::SecurityStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySubType = {"_p_FIX__SecuritySubType", "FIX::SecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityTradingEvent = {"_p_FIX__SecurityTradingEvent", "FIX::SecurityTradingEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityTradingStatus = {"_p_FIX__SecurityTradingStatus", "FIX::SecurityTradingStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityType = {"_p_FIX__SecurityType", "FIX::SecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityUpdateAction = {"_p_FIX__SecurityUpdateAction", "FIX::SecurityUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXML = {"_p_FIX__SecurityXML", "FIX::SecurityXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXMLLen = {"_p_FIX__SecurityXMLLen", "FIX::SecurityXMLLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXMLSchema = {"_p_FIX__SecurityXMLSchema", "FIX::SecurityXMLSchema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SellVolume = {"_p_FIX__SellVolume", "FIX::SellVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SellerDays = {"_p_FIX__SellerDays", "FIX::SellerDays *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderCompID = {"_p_FIX__SenderCompID", "FIX::SenderCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderLocationID = {"_p_FIX__SenderLocationID", "FIX::SenderLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderSubID = {"_p_FIX__SenderSubID", "FIX::SenderSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SendingDate = {"_p_FIX__SendingDate", "FIX::SendingDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SendingTime = {"_p_FIX__SendingTime", "FIX::SendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Seniority = {"_p_FIX__Seniority", "FIX::Seniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Session = {"_p_FIX__Session", "FIX::Session *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionID = {"_p_FIX__SessionID", "FIX::SessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionNotFound = {"_p_FIX__SessionNotFound", "FIX::SessionNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionRejectReason = {"_p_FIX__SessionRejectReason", "FIX::SessionRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionSettings = {"_p_FIX__SessionSettings", "FIX::SessionSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionStatus = {"_p_FIX__SessionStatus", "FIX::SessionStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlBrkrCode = {"_p_FIX__SettlBrkrCode", "FIX::SettlBrkrCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrAmt = {"_p_FIX__SettlCurrAmt", "FIX::SettlCurrAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrBidFxRate = {"_p_FIX__SettlCurrBidFxRate", "FIX::SettlCurrBidFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrFxRate = {"_p_FIX__SettlCurrFxRate", "FIX::SettlCurrFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrFxRateCalc = {"_p_FIX__SettlCurrFxRateCalc", "FIX::SettlCurrFxRateCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrOfferFxRate = {"_p_FIX__SettlCurrOfferFxRate", "FIX::SettlCurrOfferFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrency = {"_p_FIX__SettlCurrency", "FIX::SettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDate = {"_p_FIX__SettlDate", "FIX::SettlDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDate2 = {"_p_FIX__SettlDate2", "FIX::SettlDate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDeliveryType = {"_p_FIX__SettlDeliveryType", "FIX::SettlDeliveryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDepositoryCode = {"_p_FIX__SettlDepositoryCode", "FIX::SettlDepositoryCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstCode = {"_p_FIX__SettlInstCode", "FIX::SettlInstCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstID = {"_p_FIX__SettlInstID", "FIX::SettlInstID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstMode = {"_p_FIX__SettlInstMode", "FIX::SettlInstMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstMsgID = {"_p_FIX__SettlInstMsgID", "FIX::SettlInstMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstRefID = {"_p_FIX__SettlInstRefID", "FIX::SettlInstRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstReqID = {"_p_FIX__SettlInstReqID", "FIX::SettlInstReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstReqRejCode = {"_p_FIX__SettlInstReqRejCode", "FIX::SettlInstReqRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstSource = {"_p_FIX__SettlInstSource", "FIX::SettlInstSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstTransType = {"_p_FIX__SettlInstTransType", "FIX::SettlInstTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlLocation = {"_p_FIX__SettlLocation", "FIX::SettlLocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlMethod = {"_p_FIX__SettlMethod", "FIX::SettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligID = {"_p_FIX__SettlObligID", "FIX::SettlObligID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligMode = {"_p_FIX__SettlObligMode", "FIX::SettlObligMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligMsgID = {"_p_FIX__SettlObligMsgID", "FIX::SettlObligMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligRefID = {"_p_FIX__SettlObligRefID", "FIX::SettlObligRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligSource = {"_p_FIX__SettlObligSource", "FIX::SettlObligSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligTransType = {"_p_FIX__SettlObligTransType", "FIX::SettlObligTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyID = {"_p_FIX__SettlPartyID", "FIX::SettlPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyIDSource = {"_p_FIX__SettlPartyIDSource", "FIX::SettlPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyRole = {"_p_FIX__SettlPartyRole", "FIX::SettlPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartySubID = {"_p_FIX__SettlPartySubID", "FIX::SettlPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartySubIDType = {"_p_FIX__SettlPartySubIDType", "FIX::SettlPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPrice = {"_p_FIX__SettlPrice", "FIX::SettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPriceType = {"_p_FIX__SettlPriceType", "FIX::SettlPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlSessID = {"_p_FIX__SettlSessID", "FIX::SettlSessID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlSessSubID = {"_p_FIX__SettlSessSubID", "FIX::SettlSessSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlType = {"_p_FIX__SettlType", "FIX::SettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettleOnOpenFlag = {"_p_FIX__SettleOnOpenFlag", "FIX::SettleOnOpenFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlementCycleNo = {"_p_FIX__SettlementCycleNo", "FIX::SettlementCycleNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlmntTyp = {"_p_FIX__SettlmntTyp", "FIX::SettlmntTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SharedCommission = {"_p_FIX__SharedCommission", "FIX::SharedCommission *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Shares = {"_p_FIX__Shares", "FIX::Shares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ShortQty = {"_p_FIX__ShortQty", "FIX::ShortQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ShortSaleReason = {"_p_FIX__ShortSaleReason", "FIX::ShortSaleReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Side = {"_p_FIX__Side", "FIX::Side *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideComplianceID = {"_p_FIX__SideComplianceID", "FIX::SideComplianceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideCurrency = {"_p_FIX__SideCurrency", "FIX::SideCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideExecID = {"_p_FIX__SideExecID", "FIX::SideExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideFillStationCd = {"_p_FIX__SideFillStationCd", "FIX::SideFillStationCd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideGrossTradeAmt = {"_p_FIX__SideGrossTradeAmt", "FIX::SideGrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideLastQty = {"_p_FIX__SideLastQty", "FIX::SideLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideLiquidityInd = {"_p_FIX__SideLiquidityInd", "FIX::SideLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideMultiLegReportingType = {"_p_FIX__SideMultiLegReportingType", "FIX::SideMultiLegReportingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideQty = {"_p_FIX__SideQty", "FIX::SideQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideReasonCd = {"_p_FIX__SideReasonCd", "FIX::SideReasonCd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideSettlCurrency = {"_p_FIX__SideSettlCurrency", "FIX::SideSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTimeInForce = {"_p_FIX__SideTimeInForce", "FIX::SideTimeInForce *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTradeReportID = {"_p_FIX__SideTradeReportID", "FIX::SideTradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestamp = {"_p_FIX__SideTrdRegTimestamp", "FIX::SideTrdRegTimestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestampSrc = {"_p_FIX__SideTrdRegTimestampSrc", "FIX::SideTrdRegTimestampSrc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestampType = {"_p_FIX__SideTrdRegTimestampType", "FIX::SideTrdRegTimestampType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdSubTyp = {"_p_FIX__SideTrdSubTyp", "FIX::SideTrdSubTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValue1 = {"_p_FIX__SideValue1", "FIX::SideValue1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValue2 = {"_p_FIX__SideValue2", "FIX::SideValue2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValueInd = {"_p_FIX__SideValueInd", "FIX::SideValueInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Signature = {"_p_FIX__Signature", "FIX::Signature *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SignatureLength = {"_p_FIX__SignatureLength", "FIX::SignatureLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketAcceptor = {"_p_FIX__SocketAcceptor", "FIX::SocketAcceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketCloseFailed = {"_p_FIX__SocketCloseFailed", "FIX::SocketCloseFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketException = {"_p_FIX__SocketException", "FIX::SocketException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketInitiator = {"_p_FIX__SocketInitiator", "FIX::SocketInitiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketRecvFailed = {"_p_FIX__SocketRecvFailed", "FIX::SocketRecvFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketSendFailed = {"_p_FIX__SocketSendFailed", "FIX::SocketSendFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SolicitedFlag = {"_p_FIX__SolicitedFlag", "FIX::SolicitedFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Spread = {"_p_FIX__Spread", "FIX::Spread *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SpreadToBenchmark = {"_p_FIX__SpreadToBenchmark", "FIX::SpreadToBenchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbID = {"_p_FIX__StandInstDbID", "FIX::StandInstDbID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbName = {"_p_FIX__StandInstDbName", "FIX::StandInstDbName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbType = {"_p_FIX__StandInstDbType", "FIX::StandInstDbType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartCash = {"_p_FIX__StartCash", "FIX::StartCash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartDate = {"_p_FIX__StartDate", "FIX::StartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartMaturityMonthYear = {"_p_FIX__StartMaturityMonthYear", "FIX::StartMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartStrikePxRange = {"_p_FIX__StartStrikePxRange", "FIX::StartStrikePxRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartTickPriceRange = {"_p_FIX__StartTickPriceRange", "FIX::StartTickPriceRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StateOrProvinceOfIssue = {"_p_FIX__StateOrProvinceOfIssue", "FIX::StateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatsType = {"_p_FIX__StatsType", "FIX::StatsType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatusText = {"_p_FIX__StatusText", "FIX::StatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatusValue = {"_p_FIX__StatusValue", "FIX::StatusValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StipulationType = {"_p_FIX__StipulationType", "FIX::StipulationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StipulationValue = {"_p_FIX__StipulationValue", "FIX::StipulationValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StopPx = {"_p_FIX__StopPx", "FIX::StopPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterName = {"_p_FIX__StrategyParameterName", "FIX::StrategyParameterName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterType = {"_p_FIX__StrategyParameterType", "FIX::StrategyParameterType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterValue = {"_p_FIX__StrategyParameterValue", "FIX::StrategyParameterValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnAckType = {"_p_FIX__StreamAsgnAckType", "FIX::StreamAsgnAckType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnRejReason = {"_p_FIX__StreamAsgnRejReason", "FIX::StreamAsgnRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnReqID = {"_p_FIX__StreamAsgnReqID", "FIX::StreamAsgnReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnReqType = {"_p_FIX__StreamAsgnReqType", "FIX::StreamAsgnReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnRptID = {"_p_FIX__StreamAsgnRptID", "FIX::StreamAsgnRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnType = {"_p_FIX__StreamAsgnType", "FIX::StreamAsgnType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeCurrency = {"_p_FIX__StrikeCurrency", "FIX::StrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeExerciseStyle = {"_p_FIX__StrikeExerciseStyle", "FIX::StrikeExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeIncrement = {"_p_FIX__StrikeIncrement", "FIX::StrikeIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeMultiplier = {"_p_FIX__StrikeMultiplier", "FIX::StrikeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePrice = {"_p_FIX__StrikePrice", "FIX::StrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceBoundaryMethod = {"_p_FIX__StrikePriceBoundaryMethod", "FIX::StrikePriceBoundaryMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceBoundaryPrecision = {"_p_FIX__StrikePriceBoundaryPrecision", "FIX::StrikePriceBoundaryPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceDeterminationMethod = {"_p_FIX__StrikePriceDeterminationMethod", "FIX::StrikePriceDeterminationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeRuleID = {"_p_FIX__StrikeRuleID", "FIX::StrikeRuleID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeTime = {"_p_FIX__StrikeTime", "FIX::StrikeTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeValue = {"_p_FIX__StrikeValue", "FIX::StrikeValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StringField = {"_p_FIX__StringField", "FIX::LocalMktDateField *|FIX::MonthYearField *|FIX::CurrencyField *|FIX::DataField *|FIX::TzTimeStampField *|FIX::CountryField *|FIX::TzTimeOnlyField *|FIX::MonthField *|FIX::DayOfMonthField *|FIX::MultipleValueStringField *|FIX::MultipleStringValueField *|FIX::MultipleCharValueField *|FIX::ExchangeField *|FIX::StringField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Subject = {"_p_FIX__Subject", "FIX::Subject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SubscriptionRequestType = {"_p_FIX__SubscriptionRequestType", "FIX::SubscriptionRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SwapPoints = {"_p_FIX__SwapPoints", "FIX::SwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Symbol = {"_p_FIX__Symbol", "FIX::Symbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SymbolSfx = {"_p_FIX__SymbolSfx", "FIX::SymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SynchronizedApplication = {"_p_FIX__SynchronizedApplication", "FIX::SynchronizedApplication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TYPE__Type = {"_p_FIX__TYPE__Type", "FIX::TYPE::Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTIMEONLY = {"_p_FIX__TZTIMEONLY", "FIX::TZTIMEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTIMESTAMP = {"_p_FIX__TZTIMESTAMP", "FIX::TZTIMESTAMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTransactTime = {"_p_FIX__TZTransactTime", "FIX::TZTransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TagNotDefinedForMessage = {"_p_FIX__TagNotDefinedForMessage", "FIX::TagNotDefinedForMessage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TagOutOfOrder = {"_p_FIX__TagOutOfOrder", "FIX::TagOutOfOrder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetCompID = {"_p_FIX__TargetCompID", "FIX::TargetCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetLocationID = {"_p_FIX__TargetLocationID", "FIX::TargetLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyID = {"_p_FIX__TargetPartyID", "FIX::TargetPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyIDSource = {"_p_FIX__TargetPartyIDSource", "FIX::TargetPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyRole = {"_p_FIX__TargetPartyRole", "FIX::TargetPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategy = {"_p_FIX__TargetStrategy", "FIX::TargetStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategyParameters = {"_p_FIX__TargetStrategyParameters", "FIX::TargetStrategyParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategyPerformance = {"_p_FIX__TargetStrategyPerformance", "FIX::TargetStrategyPerformance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetSubID = {"_p_FIX__TargetSubID", "FIX::TargetSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TaxAdvantageType = {"_p_FIX__TaxAdvantageType", "FIX::TaxAdvantageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TerminationType = {"_p_FIX__TerminationType", "FIX::TerminationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TestMessageIndicator = {"_p_FIX__TestMessageIndicator", "FIX::TestMessageIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TestReqID = {"_p_FIX__TestReqID", "FIX::TestReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Text = {"_p_FIX__Text", "FIX::Text *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ThresholdAmount = {"_p_FIX__ThresholdAmount", "FIX::ThresholdAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickDirection = {"_p_FIX__TickDirection", "FIX::TickDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickIncrement = {"_p_FIX__TickIncrement", "FIX::TickIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickRuleType = {"_p_FIX__TickRuleType", "FIX::TickRuleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TierCode = {"_p_FIX__TierCode", "FIX::TierCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeBracket = {"_p_FIX__TimeBracket", "FIX::TimeBracket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeInForce = {"_p_FIX__TimeInForce", "FIX::TimeInForce *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeToExpiration = {"_p_FIX__TimeToExpiration", "FIX::TimeToExpiration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeUnit = {"_p_FIX__TimeUnit", "FIX::TimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoAccQuotes = {"_p_FIX__TotNoAccQuotes", "FIX::TotNoAccQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoAllocs = {"_p_FIX__TotNoAllocs", "FIX::TotNoAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoCxldQuotes = {"_p_FIX__TotNoCxldQuotes", "FIX::TotNoCxldQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoFills = {"_p_FIX__TotNoFills", "FIX::TotNoFills *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoOrders = {"_p_FIX__TotNoOrders", "FIX::TotNoOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoQuoteEntries = {"_p_FIX__TotNoQuoteEntries", "FIX::TotNoQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoRejQuotes = {"_p_FIX__TotNoRejQuotes", "FIX::TotNoRejQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoRelatedSym = {"_p_FIX__TotNoRelatedSym", "FIX::TotNoRelatedSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoSecurityTypes = {"_p_FIX__TotNoSecurityTypes", "FIX::TotNoSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoStrikes = {"_p_FIX__TotNoStrikes", "FIX::TotNoStrikes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumAssignmentReports = {"_p_FIX__TotNumAssignmentReports", "FIX::TotNumAssignmentReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumReports = {"_p_FIX__TotNumReports", "FIX::TotNumReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumTradeReports = {"_p_FIX__TotNumTradeReports", "FIX::TotNumTradeReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotQuoteEntries = {"_p_FIX__TotQuoteEntries", "FIX::TotQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalAccruedInterestAmt = {"_p_FIX__TotalAccruedInterestAmt", "FIX::TotalAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalAffectedOrders = {"_p_FIX__TotalAffectedOrders", "FIX::TotalAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNetValue = {"_p_FIX__TotalNetValue", "FIX::TotalNetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumPosReports = {"_p_FIX__TotalNumPosReports", "FIX::TotalNumPosReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumSecurities = {"_p_FIX__TotalNumSecurities", "FIX::TotalNumSecurities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumSecurityTypes = {"_p_FIX__TotalNumSecurityTypes", "FIX::TotalNumSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalTakedown = {"_p_FIX__TotalTakedown", "FIX::TotalTakedown *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTraded = {"_p_FIX__TotalVolumeTraded", "FIX::TotalVolumeTraded *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTradedDate = {"_p_FIX__TotalVolumeTradedDate", "FIX::TotalVolumeTradedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTradedTime = {"_p_FIX__TotalVolumeTradedTime", "FIX::TotalVolumeTradedTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesCloseTime = {"_p_FIX__TradSesCloseTime", "FIX::TradSesCloseTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesEndTime = {"_p_FIX__TradSesEndTime", "FIX::TradSesEndTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesEvent = {"_p_FIX__TradSesEvent", "FIX::TradSesEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesMethod = {"_p_FIX__TradSesMethod", "FIX::TradSesMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesMode = {"_p_FIX__TradSesMode", "FIX::TradSesMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesOpenTime = {"_p_FIX__TradSesOpenTime", "FIX::TradSesOpenTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesPreCloseTime = {"_p_FIX__TradSesPreCloseTime", "FIX::TradSesPreCloseTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesReqID = {"_p_FIX__TradSesReqID", "FIX::TradSesReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStartTime = {"_p_FIX__TradSesStartTime", "FIX::TradSesStartTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStatus = {"_p_FIX__TradSesStatus", "FIX::TradSesStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStatusRejReason = {"_p_FIX__TradSesStatusRejReason", "FIX::TradSesStatusRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesUpdateAction = {"_p_FIX__TradSesUpdateAction", "FIX::TradSesUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeAllocIndicator = {"_p_FIX__TradeAllocIndicator", "FIX::TradeAllocIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeCondition = {"_p_FIX__TradeCondition", "FIX::TradeCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeDate = {"_p_FIX__TradeDate", "FIX::TradeDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeHandlingInstr = {"_p_FIX__TradeHandlingInstr", "FIX::TradeHandlingInstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeID = {"_p_FIX__TradeID", "FIX::TradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeInputDevice = {"_p_FIX__TradeInputDevice", "FIX::TradeInputDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeInputSource = {"_p_FIX__TradeInputSource", "FIX::TradeInputSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeLegRefID = {"_p_FIX__TradeLegRefID", "FIX::TradeLegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeLinkID = {"_p_FIX__TradeLinkID", "FIX::TradeLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeOriginationDate = {"_p_FIX__TradeOriginationDate", "FIX::TradeOriginationDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradePublishIndicator = {"_p_FIX__TradePublishIndicator", "FIX::TradePublishIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportID = {"_p_FIX__TradeReportID", "FIX::TradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportRefID = {"_p_FIX__TradeReportRefID", "FIX::TradeReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportRejectReason = {"_p_FIX__TradeReportRejectReason", "FIX::TradeReportRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportTransType = {"_p_FIX__TradeReportTransType", "FIX::TradeReportTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportType = {"_p_FIX__TradeReportType", "FIX::TradeReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestID = {"_p_FIX__TradeRequestID", "FIX::TradeRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestResult = {"_p_FIX__TradeRequestResult", "FIX::TradeRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestStatus = {"_p_FIX__TradeRequestStatus", "FIX::TradeRequestStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestType = {"_p_FIX__TradeRequestType", "FIX::TradeRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeType = {"_p_FIX__TradeType", "FIX::TradeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeVolume = {"_p_FIX__TradeVolume", "FIX::TradeVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradedFlatSwitch = {"_p_FIX__TradedFlatSwitch", "FIX::TradedFlatSwitch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingCurrency = {"_p_FIX__TradingCurrency", "FIX::TradingCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingReferencePrice = {"_p_FIX__TradingReferencePrice", "FIX::TradingReferencePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionDesc = {"_p_FIX__TradingSessionDesc", "FIX::TradingSessionDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionID = {"_p_FIX__TradingSessionID", "FIX::TradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionSubID = {"_p_FIX__TradingSessionSubID", "FIX::TradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Trailer = {"_p_FIX__Trailer", "FIX::Trailer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransBkdTime = {"_p_FIX__TransBkdTime", "FIX::TransBkdTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransactTime = {"_p_FIX__TransactTime", "FIX::TransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransferReason = {"_p_FIX__TransferReason", "FIX::TransferReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdMatchID = {"_p_FIX__TrdMatchID", "FIX::TrdMatchID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestamp = {"_p_FIX__TrdRegTimestamp", "FIX::TrdRegTimestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestampOrigin = {"_p_FIX__TrdRegTimestampOrigin", "FIX::TrdRegTimestampOrigin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestampType = {"_p_FIX__TrdRegTimestampType", "FIX::TrdRegTimestampType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRepIndicator = {"_p_FIX__TrdRepIndicator", "FIX::TrdRepIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRepPartyRole = {"_p_FIX__TrdRepPartyRole", "FIX::TrdRepPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRptStatus = {"_p_FIX__TrdRptStatus", "FIX::TrdRptStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdSubType = {"_p_FIX__TrdSubType", "FIX::TrdSubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdType = {"_p_FIX__TrdType", "FIX::TrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerAction = {"_p_FIX__TriggerAction", "FIX::TriggerAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerNewPrice = {"_p_FIX__TriggerNewPrice", "FIX::TriggerNewPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerNewQty = {"_p_FIX__TriggerNewQty", "FIX::TriggerNewQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerOrderType = {"_p_FIX__TriggerOrderType", "FIX::TriggerOrderType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPrice = {"_p_FIX__TriggerPrice", "FIX::TriggerPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceDirection = {"_p_FIX__TriggerPriceDirection", "FIX::TriggerPriceDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceType = {"_p_FIX__TriggerPriceType", "FIX::TriggerPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceTypeScope = {"_p_FIX__TriggerPriceTypeScope", "FIX::TriggerPriceTypeScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityDesc = {"_p_FIX__TriggerSecurityDesc", "FIX::TriggerSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityID = {"_p_FIX__TriggerSecurityID", "FIX::TriggerSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityIDSource = {"_p_FIX__TriggerSecurityIDSource", "FIX::TriggerSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSymbol = {"_p_FIX__TriggerSymbol", "FIX::TriggerSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerTradingSessionID = {"_p_FIX__TriggerTradingSessionID", "FIX::TriggerTradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerTradingSessionSubID = {"_p_FIX__TriggerTradingSessionSubID", "FIX::TriggerTradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerType = {"_p_FIX__TriggerType", "FIX::TriggerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__URLLink = {"_p_FIX__URLLink", "FIX::URLLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCDATE = {"_p_FIX__UTCDATE", "FIX::UTCDATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCDATEONLY = {"_p_FIX__UTCDATEONLY", "FIX::UTCDATEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCTIMEONLY = {"_p_FIX__UTCTIMEONLY", "FIX::UTCTIMEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCTIMESTAMP = {"_p_FIX__UTCTIMESTAMP", "FIX::UTCTIMESTAMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAdjustedQuantity = {"_p_FIX__UnderlyingAdjustedQuantity", "FIX::UnderlyingAdjustedQuantity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAllocationPercent = {"_p_FIX__UnderlyingAllocationPercent", "FIX::UnderlyingAllocationPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAttachmentPoint = {"_p_FIX__UnderlyingAttachmentPoint", "FIX::UnderlyingAttachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCFICode = {"_p_FIX__UnderlyingCFICode", "FIX::UnderlyingCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCPProgram = {"_p_FIX__UnderlyingCPProgram", "FIX::UnderlyingCPProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCPRegType = {"_p_FIX__UnderlyingCPRegType", "FIX::UnderlyingCPRegType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCapValue = {"_p_FIX__UnderlyingCapValue", "FIX::UnderlyingCapValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCashAmount = {"_p_FIX__UnderlyingCashAmount", "FIX::UnderlyingCashAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCashType = {"_p_FIX__UnderlyingCashType", "FIX::UnderlyingCashType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCollectAmount = {"_p_FIX__UnderlyingCollectAmount", "FIX::UnderlyingCollectAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingContractMultiplier = {"_p_FIX__UnderlyingContractMultiplier", "FIX::UnderlyingContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingContractMultiplierUnit = {"_p_FIX__UnderlyingContractMultiplierUnit", "FIX::UnderlyingContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCountryOfIssue = {"_p_FIX__UnderlyingCountryOfIssue", "FIX::UnderlyingCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCouponPaymentDate = {"_p_FIX__UnderlyingCouponPaymentDate", "FIX::UnderlyingCouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCouponRate = {"_p_FIX__UnderlyingCouponRate", "FIX::UnderlyingCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCreditRating = {"_p_FIX__UnderlyingCreditRating", "FIX::UnderlyingCreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCurrency = {"_p_FIX__UnderlyingCurrency", "FIX::UnderlyingCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCurrentValue = {"_p_FIX__UnderlyingCurrentValue", "FIX::UnderlyingCurrentValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDeliveryAmount = {"_p_FIX__UnderlyingDeliveryAmount", "FIX::UnderlyingDeliveryAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDetachmentPoint = {"_p_FIX__UnderlyingDetachmentPoint", "FIX::UnderlyingDetachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDirtyPrice = {"_p_FIX__UnderlyingDirtyPrice", "FIX::UnderlyingDirtyPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingEndPrice = {"_p_FIX__UnderlyingEndPrice", "FIX::UnderlyingEndPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingEndValue = {"_p_FIX__UnderlyingEndValue", "FIX::UnderlyingEndValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingExerciseStyle = {"_p_FIX__UnderlyingExerciseStyle", "FIX::UnderlyingExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFXRate = {"_p_FIX__UnderlyingFXRate", "FIX::UnderlyingFXRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFXRateCalc = {"_p_FIX__UnderlyingFXRateCalc", "FIX::UnderlyingFXRateCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFactor = {"_p_FIX__UnderlyingFactor", "FIX::UnderlyingFactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFlowScheduleType = {"_p_FIX__UnderlyingFlowScheduleType", "FIX::UnderlyingFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIDSource = {"_p_FIX__UnderlyingIDSource", "FIX::UnderlyingIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrRegistry = {"_p_FIX__UnderlyingInstrRegistry", "FIX::UnderlyingInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyID = {"_p_FIX__UnderlyingInstrumentPartyID", "FIX::UnderlyingInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyIDSource = {"_p_FIX__UnderlyingInstrumentPartyIDSource", "FIX::UnderlyingInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyRole = {"_p_FIX__UnderlyingInstrumentPartyRole", "FIX::UnderlyingInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartySubID = {"_p_FIX__UnderlyingInstrumentPartySubID", "FIX::UnderlyingInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartySubIDType = {"_p_FIX__UnderlyingInstrumentPartySubIDType", "FIX::UnderlyingInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIssueDate = {"_p_FIX__UnderlyingIssueDate", "FIX::UnderlyingIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIssuer = {"_p_FIX__UnderlyingIssuer", "FIX::UnderlyingIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLastPx = {"_p_FIX__UnderlyingLastPx", "FIX::UnderlyingLastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLastQty = {"_p_FIX__UnderlyingLastQty", "FIX::UnderlyingLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegCFICode = {"_p_FIX__UnderlyingLegCFICode", "FIX::UnderlyingLegCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityDate = {"_p_FIX__UnderlyingLegMaturityDate", "FIX::UnderlyingLegMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityMonthYear = {"_p_FIX__UnderlyingLegMaturityMonthYear", "FIX::UnderlyingLegMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityTime = {"_p_FIX__UnderlyingLegMaturityTime", "FIX::UnderlyingLegMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegOptAttribute = {"_p_FIX__UnderlyingLegOptAttribute", "FIX::UnderlyingLegOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegPutOrCall = {"_p_FIX__UnderlyingLegPutOrCall", "FIX::UnderlyingLegPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityAltID = {"_p_FIX__UnderlyingLegSecurityAltID", "FIX::UnderlyingLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityAltIDSource = {"_p_FIX__UnderlyingLegSecurityAltIDSource", "FIX::UnderlyingLegSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityDesc = {"_p_FIX__UnderlyingLegSecurityDesc", "FIX::UnderlyingLegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityExchange = {"_p_FIX__UnderlyingLegSecurityExchange", "FIX::UnderlyingLegSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityID = {"_p_FIX__UnderlyingLegSecurityID", "FIX::UnderlyingLegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityIDSource = {"_p_FIX__UnderlyingLegSecurityIDSource", "FIX::UnderlyingLegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecuritySubType = {"_p_FIX__UnderlyingLegSecuritySubType", "FIX::UnderlyingLegSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityType = {"_p_FIX__UnderlyingLegSecurityType", "FIX::UnderlyingLegSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegStrikePrice = {"_p_FIX__UnderlyingLegStrikePrice", "FIX::UnderlyingLegStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSymbol = {"_p_FIX__UnderlyingLegSymbol", "FIX::UnderlyingLegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSymbolSfx = {"_p_FIX__UnderlyingLegSymbolSfx", "FIX::UnderlyingLegSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLocaleOfIssue = {"_p_FIX__UnderlyingLocaleOfIssue", "FIX::UnderlyingLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityDate = {"_p_FIX__UnderlyingMaturityDate", "FIX::UnderlyingMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityDay = {"_p_FIX__UnderlyingMaturityDay", "FIX::UnderlyingMaturityDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityMonthYear = {"_p_FIX__UnderlyingMaturityMonthYear", "FIX::UnderlyingMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityTime = {"_p_FIX__UnderlyingMaturityTime", "FIX::UnderlyingMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingNotionalPercentageOutstanding = {"_p_FIX__UnderlyingNotionalPercentageOutstanding", "FIX::UnderlyingNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingOptAttribute = {"_p_FIX__UnderlyingOptAttribute", "FIX::UnderlyingOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding = {"_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding", "FIX::UnderlyingOriginalNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPayAmount = {"_p_FIX__UnderlyingPayAmount", "FIX::UnderlyingPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceDeterminationMethod = {"_p_FIX__UnderlyingPriceDeterminationMethod", "FIX::UnderlyingPriceDeterminationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceUnitOfMeasure = {"_p_FIX__UnderlyingPriceUnitOfMeasure", "FIX::UnderlyingPriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty = {"_p_FIX__UnderlyingPriceUnitOfMeasureQty", "FIX::UnderlyingPriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingProduct = {"_p_FIX__UnderlyingProduct", "FIX::UnderlyingProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPutOrCall = {"_p_FIX__UnderlyingPutOrCall", "FIX::UnderlyingPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPx = {"_p_FIX__UnderlyingPx", "FIX::UnderlyingPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingQty = {"_p_FIX__UnderlyingQty", "FIX::UnderlyingQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRedemptionDate = {"_p_FIX__UnderlyingRedemptionDate", "FIX::UnderlyingRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepoCollateralSecurityType = {"_p_FIX__UnderlyingRepoCollateralSecurityType", "FIX::UnderlyingRepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepurchaseRate = {"_p_FIX__UnderlyingRepurchaseRate", "FIX::UnderlyingRepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepurchaseTerm = {"_p_FIX__UnderlyingRepurchaseTerm", "FIX::UnderlyingRepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRestructuringType = {"_p_FIX__UnderlyingRestructuringType", "FIX::UnderlyingRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityAltID = {"_p_FIX__UnderlyingSecurityAltID", "FIX::UnderlyingSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityAltIDSource = {"_p_FIX__UnderlyingSecurityAltIDSource", "FIX::UnderlyingSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityDesc = {"_p_FIX__UnderlyingSecurityDesc", "FIX::UnderlyingSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityExchange = {"_p_FIX__UnderlyingSecurityExchange", "FIX::UnderlyingSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityID = {"_p_FIX__UnderlyingSecurityID", "FIX::UnderlyingSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityIDSource = {"_p_FIX__UnderlyingSecurityIDSource", "FIX::UnderlyingSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecuritySubType = {"_p_FIX__UnderlyingSecuritySubType", "FIX::UnderlyingSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityType = {"_p_FIX__UnderlyingSecurityType", "FIX::UnderlyingSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSeniority = {"_p_FIX__UnderlyingSeniority", "FIX::UnderlyingSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlMethod = {"_p_FIX__UnderlyingSettlMethod", "FIX::UnderlyingSettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlPrice = {"_p_FIX__UnderlyingSettlPrice", "FIX::UnderlyingSettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlPriceType = {"_p_FIX__UnderlyingSettlPriceType", "FIX::UnderlyingSettlPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementDate = {"_p_FIX__UnderlyingSettlementDate", "FIX::UnderlyingSettlementDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementStatus = {"_p_FIX__UnderlyingSettlementStatus", "FIX::UnderlyingSettlementStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementType = {"_p_FIX__UnderlyingSettlementType", "FIX::UnderlyingSettlementType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStartValue = {"_p_FIX__UnderlyingStartValue", "FIX::UnderlyingStartValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStateOrProvinceOfIssue = {"_p_FIX__UnderlyingStateOrProvinceOfIssue", "FIX::UnderlyingStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStipType = {"_p_FIX__UnderlyingStipType", "FIX::UnderlyingStipType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStipValue = {"_p_FIX__UnderlyingStipValue", "FIX::UnderlyingStipValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStrikeCurrency = {"_p_FIX__UnderlyingStrikeCurrency", "FIX::UnderlyingStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStrikePrice = {"_p_FIX__UnderlyingStrikePrice", "FIX::UnderlyingStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSymbol = {"_p_FIX__UnderlyingSymbol", "FIX::UnderlyingSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSymbolSfx = {"_p_FIX__UnderlyingSymbolSfx", "FIX::UnderlyingSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTimeUnit = {"_p_FIX__UnderlyingTimeUnit", "FIX::UnderlyingTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTradingSessionID = {"_p_FIX__UnderlyingTradingSessionID", "FIX::UnderlyingTradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTradingSessionSubID = {"_p_FIX__UnderlyingTradingSessionSubID", "FIX::UnderlyingTradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingUnitOfMeasure = {"_p_FIX__UnderlyingUnitOfMeasure", "FIX::UnderlyingUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingUnitOfMeasureQty = {"_p_FIX__UnderlyingUnitOfMeasureQty", "FIX::UnderlyingUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyID = {"_p_FIX__UndlyInstrumentPartyID", "FIX::UndlyInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyIDSource = {"_p_FIX__UndlyInstrumentPartyIDSource", "FIX::UndlyInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyRole = {"_p_FIX__UndlyInstrumentPartyRole", "FIX::UndlyInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartySubID = {"_p_FIX__UndlyInstrumentPartySubID", "FIX::UndlyInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartySubIDType = {"_p_FIX__UndlyInstrumentPartySubIDType", "FIX::UndlyInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnitOfMeasure = {"_p_FIX__UnitOfMeasure", "FIX::UnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnitOfMeasureQty = {"_p_FIX__UnitOfMeasureQty", "FIX::UnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsolicitedIndicator = {"_p_FIX__UnsolicitedIndicator", "FIX::UnsolicitedIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsupportedMessageType = {"_p_FIX__UnsupportedMessageType", "FIX::UnsupportedMessageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsupportedVersion = {"_p_FIX__UnsupportedVersion", "FIX::UnsupportedVersion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Urgency = {"_p_FIX__Urgency", "FIX::Urgency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserRequestID = {"_p_FIX__UserRequestID", "FIX::UserRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserRequestType = {"_p_FIX__UserRequestType", "FIX::UserRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserStatus = {"_p_FIX__UserStatus", "FIX::UserStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserStatusText = {"_p_FIX__UserStatusText", "FIX::UserStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Username = {"_p_FIX__Username", "FIX::Username *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcDateField = {"_p_FIX__UtcDateField", "FIX::UtcDateField *|FIX::UtcDateOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeOnlyField = {"_p_FIX__UtcTimeOnlyField", "FIX::UtcTimeOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeStampField = {"_p_FIX__UtcTimeStampField", "FIX::UtcTimeStampField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValidUntilTime = {"_p_FIX__ValidUntilTime", "FIX::ValidUntilTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValuationMethod = {"_p_FIX__ValuationMethod", "FIX::ValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValueOfFutures = {"_p_FIX__ValueOfFutures", "FIX::ValueOfFutures *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__VenueType = {"_p_FIX__VenueType", "FIX::VenueType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Volatility = {"_p_FIX__Volatility", "FIX::Volatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WaveNo = {"_p_FIX__WaveNo", "FIX::WaveNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WorkingIndicator = {"_p_FIX__WorkingIndicator", "FIX::WorkingIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WtAverageLiquidity = {"_p_FIX__WtAverageLiquidity", "FIX::WtAverageLiquidity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XMLDATA = {"_p_FIX__XMLDATA", "FIX::XMLDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XmlData = {"_p_FIX__XmlData", "FIX::XmlData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XmlDataLen = {"_p_FIX__XmlDataLen", "FIX::XmlDataLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Yield = {"_p_FIX__Yield", "FIX::Yield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldCalcDate = {"_p_FIX__YieldCalcDate", "FIX::YieldCalcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionDate = {"_p_FIX__YieldRedemptionDate", "FIX::YieldRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionPrice = {"_p_FIX__YieldRedemptionPrice", "FIX::YieldRedemptionPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionPriceType = {"_p_FIX__YieldRedemptionPriceType", "FIX::YieldRedemptionPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldType = {"_p_FIX__YieldType", "FIX::YieldType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fields = {"_p_Fields", "Fields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Group = {"_p_Group", "Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Groups = {"_p_Groups", "Groups *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntArray = {"_p_IntArray", "IntArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntField = {"_p_IntField", "IntField *|LengthField *|NumInGroupField *|SeqNumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Log = {"_p_Log", "Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LogFactory = {"_p_LogFactory", "LogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MessageStore = {"_p_MessageStore", "MessageStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MessageStoreFactory = {"_p_MessageStoreFactory", "MessageStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MsgType = {"_p_MsgType", "MsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mutex = {"_p_Mutex", "Mutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Responder = {"_p_Responder", "Responder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SessionID = {"_p_SessionID", "SessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StringField = {"_p_StringField", "TzTimeStampField *|LocalMktDateField *|DayOfMonthField *|MonthField *|DataField *|ExchangeField *|MultipleCharValueField *|MultipleStringValueField *|TzTimeOnlyField *|CountryField *|MonthYearField *|MultipleValueStringField *|CurrencyField *|StringField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeRange = {"_p_TimeRange", "TimeRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDate = {"_p_UtcDate", "UtcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDateField = {"_p_UtcDateField", "UtcDateField *|UtcDateOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcTimeOnly = {"_p_UtcTimeOnly", "UtcTimeOnly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcTimeStamp = {"_p_UtcTimeStamp", "UtcTimeStamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_g_const_iterator = {"_p_g_const_iterator", "g_const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_g_iterator = {"_p_g_iterator", "g_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_message_order = {"_p_message_order", "message_order *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FIX__DataDictionary = {"_p_p_FIX__DataDictionary", "FIX::DataDictionary **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_FIX__SessionID_t = {"_p_std__setT_FIX__SessionID_t", "std::set< FIX::SessionID > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string__size_type = {"_p_std__string__size_type", "std::string::size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ApplVerID,
  &_swigt__p_Application,
  &_swigt__p_BeginString,
  &_swigt__p_DOMDocumentPtr,
  &_swigt__p_Data,
  &_swigt__p_DataDictionary,
  &_swigt__p_DataDictionaryProvider,
  &_swigt__p_Dictionaries,
  &_swigt__p_DoubleField,
  &_swigt__p_FIX__AMT,
  &_swigt__p_FIX__Acceptor,
  &_swigt__p_FIX__Account,
  &_swigt__p_FIX__AccountType,
  &_swigt__p_FIX__AccruedInterestAmt,
  &_swigt__p_FIX__AccruedInterestRate,
  &_swigt__p_FIX__AcctIDSource,
  &_swigt__p_FIX__Adjustment,
  &_swigt__p_FIX__AdjustmentType,
  &_swigt__p_FIX__AdvId,
  &_swigt__p_FIX__AdvRefID,
  &_swigt__p_FIX__AdvSide,
  &_swigt__p_FIX__AdvTransType,
  &_swigt__p_FIX__AffectedOrderID,
  &_swigt__p_FIX__AffectedSecondaryOrderID,
  &_swigt__p_FIX__AffirmStatus,
  &_swigt__p_FIX__AggregatedBook,
  &_swigt__p_FIX__AggressorIndicator,
  &_swigt__p_FIX__AgreementCurrency,
  &_swigt__p_FIX__AgreementDate,
  &_swigt__p_FIX__AgreementDesc,
  &_swigt__p_FIX__AgreementID,
  &_swigt__p_FIX__AllocAccount,
  &_swigt__p_FIX__AllocAccountType,
  &_swigt__p_FIX__AllocAccruedInterestAmt,
  &_swigt__p_FIX__AllocAcctIDSource,
  &_swigt__p_FIX__AllocAvgPx,
  &_swigt__p_FIX__AllocCancReplaceReason,
  &_swigt__p_FIX__AllocClearingFeeIndicator,
  &_swigt__p_FIX__AllocCustomerCapacity,
  &_swigt__p_FIX__AllocHandlInst,
  &_swigt__p_FIX__AllocID,
  &_swigt__p_FIX__AllocInterestAtMaturity,
  &_swigt__p_FIX__AllocIntermedReqType,
  &_swigt__p_FIX__AllocLinkID,
  &_swigt__p_FIX__AllocLinkType,
  &_swigt__p_FIX__AllocMethod,
  &_swigt__p_FIX__AllocNetMoney,
  &_swigt__p_FIX__AllocNoOrdersType,
  &_swigt__p_FIX__AllocPositionEffect,
  &_swigt__p_FIX__AllocPrice,
  &_swigt__p_FIX__AllocQty,
  &_swigt__p_FIX__AllocRejCode,
  &_swigt__p_FIX__AllocReportID,
  &_swigt__p_FIX__AllocReportRefID,
  &_swigt__p_FIX__AllocReportType,
  &_swigt__p_FIX__AllocSettlCurrAmt,
  &_swigt__p_FIX__AllocSettlCurrency,
  &_swigt__p_FIX__AllocSettlInstType,
  &_swigt__p_FIX__AllocShares,
  &_swigt__p_FIX__AllocStatus,
  &_swigt__p_FIX__AllocText,
  &_swigt__p_FIX__AllocTransType,
  &_swigt__p_FIX__AllocType,
  &_swigt__p_FIX__AllowableOneSidednessCurr,
  &_swigt__p_FIX__AllowableOneSidednessPct,
  &_swigt__p_FIX__AllowableOneSidednessValue,
  &_swigt__p_FIX__AltMDSourceID,
  &_swigt__p_FIX__ApplBegSeqNum,
  &_swigt__p_FIX__ApplEndSeqNum,
  &_swigt__p_FIX__ApplExtID,
  &_swigt__p_FIX__ApplID,
  &_swigt__p_FIX__ApplLastSeqNum,
  &_swigt__p_FIX__ApplNewSeqNum,
  &_swigt__p_FIX__ApplQueueAction,
  &_swigt__p_FIX__ApplQueueDepth,
  &_swigt__p_FIX__ApplQueueMax,
  &_swigt__p_FIX__ApplQueueResolution,
  &_swigt__p_FIX__ApplReportID,
  &_swigt__p_FIX__ApplReportType,
  &_swigt__p_FIX__ApplReqID,
  &_swigt__p_FIX__ApplReqType,
  &_swigt__p_FIX__ApplResendFlag,
  &_swigt__p_FIX__ApplResponseError,
  &_swigt__p_FIX__ApplResponseID,
  &_swigt__p_FIX__ApplResponseType,
  &_swigt__p_FIX__ApplSeqNum,
  &_swigt__p_FIX__ApplTotalMessageCount,
  &_swigt__p_FIX__ApplVerID,
  &_swigt__p_FIX__Application,
  &_swigt__p_FIX__AsOfIndicator,
  &_swigt__p_FIX__AsgnRptID,
  &_swigt__p_FIX__AssignmentMethod,
  &_swigt__p_FIX__AssignmentUnit,
  &_swigt__p_FIX__AttachmentPoint,
  &_swigt__p_FIX__AutoAcceptIndicator,
  &_swigt__p_FIX__AvgParPx,
  &_swigt__p_FIX__AvgPrxPrecision,
  &_swigt__p_FIX__AvgPx,
  &_swigt__p_FIX__AvgPxIndicator,
  &_swigt__p_FIX__AvgPxPrecision,
  &_swigt__p_FIX__BOOLEAN,
  &_swigt__p_FIX__BasisFeatureDate,
  &_swigt__p_FIX__BasisFeaturePrice,
  &_swigt__p_FIX__BasisPxType,
  &_swigt__p_FIX__BeginSeqNo,
  &_swigt__p_FIX__BeginString,
  &_swigt__p_FIX__Benchmark,
  &_swigt__p_FIX__BenchmarkCurveCurrency,
  &_swigt__p_FIX__BenchmarkCurveName,
  &_swigt__p_FIX__BenchmarkCurvePoint,
  &_swigt__p_FIX__BenchmarkPrice,
  &_swigt__p_FIX__BenchmarkPriceType,
  &_swigt__p_FIX__BenchmarkSecurityID,
  &_swigt__p_FIX__BenchmarkSecurityIDSource,
  &_swigt__p_FIX__BidDescriptor,
  &_swigt__p_FIX__BidDescriptorType,
  &_swigt__p_FIX__BidForwardPoints,
  &_swigt__p_FIX__BidForwardPoints2,
  &_swigt__p_FIX__BidID,
  &_swigt__p_FIX__BidPx,
  &_swigt__p_FIX__BidRequestTransType,
  &_swigt__p_FIX__BidSize,
  &_swigt__p_FIX__BidSpotRate,
  &_swigt__p_FIX__BidSwapPoints,
  &_swigt__p_FIX__BidTradeType,
  &_swigt__p_FIX__BidType,
  &_swigt__p_FIX__BidYield,
  &_swigt__p_FIX__BodyLength,
  &_swigt__p_FIX__BookingRefID,
  &_swigt__p_FIX__BookingType,
  &_swigt__p_FIX__BookingUnit,
  &_swigt__p_FIX__BoolField,
  &_swigt__p_FIX__BrokerOfCredit,
  &_swigt__p_FIX__BusinessRejectReason,
  &_swigt__p_FIX__BusinessRejectRefID,
  &_swigt__p_FIX__BuyVolume,
  &_swigt__p_FIX__CFICode,
  &_swigt__p_FIX__CHAR,
  &_swigt__p_FIX__COUNTRY,
  &_swigt__p_FIX__CPProgram,
  &_swigt__p_FIX__CPRegType,
  &_swigt__p_FIX__CURRENCY,
  &_swigt__p_FIX__CalculatedCcyLastQty,
  &_swigt__p_FIX__CancellationRights,
  &_swigt__p_FIX__CapPrice,
  &_swigt__p_FIX__CardExpDate,
  &_swigt__p_FIX__CardHolderName,
  &_swigt__p_FIX__CardIssNo,
  &_swigt__p_FIX__CardIssNum,
  &_swigt__p_FIX__CardNumber,
  &_swigt__p_FIX__CardStartDate,
  &_swigt__p_FIX__CashDistribAgentAcctName,
  &_swigt__p_FIX__CashDistribAgentAcctNumber,
  &_swigt__p_FIX__CashDistribAgentCode,
  &_swigt__p_FIX__CashDistribAgentName,
  &_swigt__p_FIX__CashDistribCurr,
  &_swigt__p_FIX__CashDistribPayRef,
  &_swigt__p_FIX__CashMargin,
  &_swigt__p_FIX__CashOrderQty,
  &_swigt__p_FIX__CashOutstanding,
  &_swigt__p_FIX__CashSettlAgentAcctName,
  &_swigt__p_FIX__CashSettlAgentAcctNum,
  &_swigt__p_FIX__CashSettlAgentCode,
  &_swigt__p_FIX__CashSettlAgentContactName,
  &_swigt__p_FIX__CashSettlAgentContactPhone,
  &_swigt__p_FIX__CashSettlAgentName,
  &_swigt__p_FIX__CcyAmt,
  &_swigt__p_FIX__CharField,
  &_swigt__p_FIX__CheckSum,
  &_swigt__p_FIX__CheckSumField,
  &_swigt__p_FIX__ClOrdID,
  &_swigt__p_FIX__ClOrdLinkID,
  &_swigt__p_FIX__ClearingAccount,
  &_swigt__p_FIX__ClearingBusinessDate,
  &_swigt__p_FIX__ClearingFeeIndicator,
  &_swigt__p_FIX__ClearingFirm,
  &_swigt__p_FIX__ClearingInstruction,
  &_swigt__p_FIX__ClientBidID,
  &_swigt__p_FIX__ClientID,
  &_swigt__p_FIX__CollAction,
  &_swigt__p_FIX__CollApplType,
  &_swigt__p_FIX__CollAsgnID,
  &_swigt__p_FIX__CollAsgnReason,
  &_swigt__p_FIX__CollAsgnRefID,
  &_swigt__p_FIX__CollAsgnRejectReason,
  &_swigt__p_FIX__CollAsgnRespType,
  &_swigt__p_FIX__CollAsgnTransType,
  &_swigt__p_FIX__CollInquiryID,
  &_swigt__p_FIX__CollInquiryQualifier,
  &_swigt__p_FIX__CollInquiryResult,
  &_swigt__p_FIX__CollInquiryStatus,
  &_swigt__p_FIX__CollReqID,
  &_swigt__p_FIX__CollRespID,
  &_swigt__p_FIX__CollRptID,
  &_swigt__p_FIX__CollStatus,
  &_swigt__p_FIX__CommCurrency,
  &_swigt__p_FIX__CommType,
  &_swigt__p_FIX__Commission,
  &_swigt__p_FIX__ComplexEventCondition,
  &_swigt__p_FIX__ComplexEventEndDate,
  &_swigt__p_FIX__ComplexEventEndTime,
  &_swigt__p_FIX__ComplexEventPrice,
  &_swigt__p_FIX__ComplexEventPriceBoundaryMethod,
  &_swigt__p_FIX__ComplexEventPriceBoundaryPrecision,
  &_swigt__p_FIX__ComplexEventPriceTimeType,
  &_swigt__p_FIX__ComplexEventStartDate,
  &_swigt__p_FIX__ComplexEventStartTime,
  &_swigt__p_FIX__ComplexEventType,
  &_swigt__p_FIX__ComplexOptPayoutAmount,
  &_swigt__p_FIX__ComplianceID,
  &_swigt__p_FIX__Concession,
  &_swigt__p_FIX__ConfigError,
  &_swigt__p_FIX__ConfirmID,
  &_swigt__p_FIX__ConfirmRefID,
  &_swigt__p_FIX__ConfirmRejReason,
  &_swigt__p_FIX__ConfirmReqID,
  &_swigt__p_FIX__ConfirmStatus,
  &_swigt__p_FIX__ConfirmTransType,
  &_swigt__p_FIX__ConfirmType,
  &_swigt__p_FIX__ContAmtCurr,
  &_swigt__p_FIX__ContAmtType,
  &_swigt__p_FIX__ContAmtValue,
  &_swigt__p_FIX__ContIntRptID,
  &_swigt__p_FIX__ContingencyType,
  &_swigt__p_FIX__ContraBroker,
  &_swigt__p_FIX__ContraLegRefID,
  &_swigt__p_FIX__ContraTradeQty,
  &_swigt__p_FIX__ContraTradeTime,
  &_swigt__p_FIX__ContraTrader,
  &_swigt__p_FIX__ContractMultiplier,
  &_swigt__p_FIX__ContractMultiplierUnit,
  &_swigt__p_FIX__ContractSettlMonth,
  &_swigt__p_FIX__ContraryInstructionIndicator,
  &_swigt__p_FIX__CopyMsgIndicator,
  &_swigt__p_FIX__CorporateAction,
  &_swigt__p_FIX__Country,
  &_swigt__p_FIX__CountryOfIssue,
  &_swigt__p_FIX__CouponPaymentDate,
  &_swigt__p_FIX__CouponRate,
  &_swigt__p_FIX__CoveredOrUncovered,
  &_swigt__p_FIX__CreditRating,
  &_swigt__p_FIX__CrossID,
  &_swigt__p_FIX__CrossPercent,
  &_swigt__p_FIX__CrossPrioritization,
  &_swigt__p_FIX__CrossType,
  &_swigt__p_FIX__CstmApplVerID,
  &_swigt__p_FIX__CumQty,
  &_swigt__p_FIX__Currency,
  &_swigt__p_FIX__CurrencyRatio,
  &_swigt__p_FIX__CustDirectedOrder,
  &_swigt__p_FIX__CustOrderCapacity,
  &_swigt__p_FIX__CustOrderHandlingInst,
  &_swigt__p_FIX__CustomerOrFirm,
  &_swigt__p_FIX__CxlQty,
  &_swigt__p_FIX__CxlRejReason,
  &_swigt__p_FIX__CxlRejResponseTo,
  &_swigt__p_FIX__CxlType,
  &_swigt__p_FIX__DATA,
  &_swigt__p_FIX__DAYOFMONTH,
  &_swigt__p_FIX__DKReason,
  &_swigt__p_FIX__DataDictionary,
  &_swigt__p_FIX__DataDictionaryNotFound,
  &_swigt__p_FIX__DateOfBirth,
  &_swigt__p_FIX__DatedDate,
  &_swigt__p_FIX__DayAvgPx,
  &_swigt__p_FIX__DayBookingInst,
  &_swigt__p_FIX__DayCumQty,
  &_swigt__p_FIX__DayOrderQty,
  &_swigt__p_FIX__DealingCapacity,
  &_swigt__p_FIX__DefBidSize,
  &_swigt__p_FIX__DefOfferSize,
  &_swigt__p_FIX__DefaultApplExtID,
  &_swigt__p_FIX__DefaultApplVerID,
  &_swigt__p_FIX__DefaultCstmApplVerID,
  &_swigt__p_FIX__DefaultVerIndicator,
  &_swigt__p_FIX__DeleteReason,
  &_swigt__p_FIX__DeliverToCompID,
  &_swigt__p_FIX__DeliverToLocationID,
  &_swigt__p_FIX__DeliverToSubID,
  &_swigt__p_FIX__DeliveryDate,
  &_swigt__p_FIX__DeliveryForm,
  &_swigt__p_FIX__DeliveryType,
  &_swigt__p_FIX__DerivFlexProductEligibilityIndicator,
  &_swigt__p_FIX__DerivativeCFICode,
  &_swigt__p_FIX__DerivativeCapPrice,
  &_swigt__p_FIX__DerivativeContractMultiplier,
  &_swigt__p_FIX__DerivativeContractMultiplierUnit,
  &_swigt__p_FIX__DerivativeContractSettlMonth,
  &_swigt__p_FIX__DerivativeCountryOfIssue,
  &_swigt__p_FIX__DerivativeEncodedIssuer,
  &_swigt__p_FIX__DerivativeEncodedIssuerLen,
  &_swigt__p_FIX__DerivativeEncodedSecurityDesc,
  &_swigt__p_FIX__DerivativeEncodedSecurityDescLen,
  &_swigt__p_FIX__DerivativeEventDate,
  &_swigt__p_FIX__DerivativeEventPx,
  &_swigt__p_FIX__DerivativeEventText,
  &_swigt__p_FIX__DerivativeEventTime,
  &_swigt__p_FIX__DerivativeEventType,
  &_swigt__p_FIX__DerivativeExerciseStyle,
  &_swigt__p_FIX__DerivativeFloorPrice,
  &_swigt__p_FIX__DerivativeFlowScheduleType,
  &_swigt__p_FIX__DerivativeFuturesValuationMethod,
  &_swigt__p_FIX__DerivativeInstrAttribType,
  &_swigt__p_FIX__DerivativeInstrAttribValue,
  &_swigt__p_FIX__DerivativeInstrRegistry,
  &_swigt__p_FIX__DerivativeInstrmtAssignmentMethod,
  &_swigt__p_FIX__DerivativeInstrumentPartyID,
  &_swigt__p_FIX__DerivativeInstrumentPartyIDSource,
  &_swigt__p_FIX__DerivativeInstrumentPartyRole,
  &_swigt__p_FIX__DerivativeInstrumentPartySubID,
  &_swigt__p_FIX__DerivativeInstrumentPartySubIDType,
  &_swigt__p_FIX__DerivativeIssueDate,
  &_swigt__p_FIX__DerivativeIssuer,
  &_swigt__p_FIX__DerivativeListMethod,
  &_swigt__p_FIX__DerivativeLocaleOfIssue,
  &_swigt__p_FIX__DerivativeMaturityDate,
  &_swigt__p_FIX__DerivativeMaturityMonthYear,
  &_swigt__p_FIX__DerivativeMaturityTime,
  &_swigt__p_FIX__DerivativeMinPriceIncrement,
  &_swigt__p_FIX__DerivativeMinPriceIncrementAmount,
  &_swigt__p_FIX__DerivativeNTPositionLimit,
  &_swigt__p_FIX__DerivativeOptAttribute,
  &_swigt__p_FIX__DerivativeOptPayAmount,
  &_swigt__p_FIX__DerivativePositionLimit,
  &_swigt__p_FIX__DerivativePriceQuoteMethod,
  &_swigt__p_FIX__DerivativePriceUnitOfMeasure,
  &_swigt__p_FIX__DerivativePriceUnitOfMeasureQty,
  &_swigt__p_FIX__DerivativeProduct,
  &_swigt__p_FIX__DerivativeProductComplex,
  &_swigt__p_FIX__DerivativePutOrCall,
  &_swigt__p_FIX__DerivativeSecurityAltID,
  &_swigt__p_FIX__DerivativeSecurityAltIDSource,
  &_swigt__p_FIX__DerivativeSecurityDesc,
  &_swigt__p_FIX__DerivativeSecurityExchange,
  &_swigt__p_FIX__DerivativeSecurityGroup,
  &_swigt__p_FIX__DerivativeSecurityID,
  &_swigt__p_FIX__DerivativeSecurityIDSource,
  &_swigt__p_FIX__DerivativeSecurityStatus,
  &_swigt__p_FIX__DerivativeSecuritySubType,
  &_swigt__p_FIX__DerivativeSecurityType,
  &_swigt__p_FIX__DerivativeSecurityXML,
  &_swigt__p_FIX__DerivativeSecurityXMLLen,
  &_swigt__p_FIX__DerivativeSecurityXMLSchema,
  &_swigt__p_FIX__DerivativeSettlMethod,
  &_swigt__p_FIX__DerivativeSettleOnOpenFlag,
  &_swigt__p_FIX__DerivativeStateOrProvinceOfIssue,
  &_swigt__p_FIX__DerivativeStrikeCurrency,
  &_swigt__p_FIX__DerivativeStrikeMultiplier,
  &_swigt__p_FIX__DerivativeStrikePrice,
  &_swigt__p_FIX__DerivativeStrikeValue,
  &_swigt__p_FIX__DerivativeSymbol,
  &_swigt__p_FIX__DerivativeSymbolSfx,
  &_swigt__p_FIX__DerivativeTimeUnit,
  &_swigt__p_FIX__DerivativeUnitOfMeasure,
  &_swigt__p_FIX__DerivativeUnitOfMeasureQty,
  &_swigt__p_FIX__DerivativeValuationMethod,
  &_swigt__p_FIX__Designation,
  &_swigt__p_FIX__DeskID,
  &_swigt__p_FIX__DeskOrderHandlingInst,
  &_swigt__p_FIX__DeskType,
  &_swigt__p_FIX__DeskTypeSource,
  &_swigt__p_FIX__DetachmentPoint,
  &_swigt__p_FIX__Dictionary,
  &_swigt__p_FIX__Dictionary__Data__const_iterator,
  &_swigt__p_FIX__DiscretionInst,
  &_swigt__p_FIX__DiscretionLimitType,
  &_swigt__p_FIX__DiscretionMoveType,
  &_swigt__p_FIX__DiscretionOffset,
  &_swigt__p_FIX__DiscretionOffsetType,
  &_swigt__p_FIX__DiscretionOffsetValue,
  &_swigt__p_FIX__DiscretionPrice,
  &_swigt__p_FIX__DiscretionRoundDirection,
  &_swigt__p_FIX__DiscretionScope,
  &_swigt__p_FIX__DisplayHighQty,
  &_swigt__p_FIX__DisplayLowQty,
  &_swigt__p_FIX__DisplayMethod,
  &_swigt__p_FIX__DisplayMinIncr,
  &_swigt__p_FIX__DisplayQty,
  &_swigt__p_FIX__DisplayWhen,
  &_swigt__p_FIX__DistribPaymentMethod,
  &_swigt__p_FIX__DistribPercentage,
  &_swigt__p_FIX__DividendYield,
  &_swigt__p_FIX__DlvyInst,
  &_swigt__p_FIX__DlvyInstType,
  &_swigt__p_FIX__DoNotSend,
  &_swigt__p_FIX__DoubleField,
  &_swigt__p_FIX__DueToRelated,
  &_swigt__p_FIX__DuplicateFieldNumber,
  &_swigt__p_FIX__EFPTrackingError,
  &_swigt__p_FIX__EXCHANGE,
  &_swigt__p_FIX__EffectiveTime,
  &_swigt__p_FIX__EmailThreadID,
  &_swigt__p_FIX__EmailType,
  &_swigt__p_FIX__EncodedAllocText,
  &_swigt__p_FIX__EncodedAllocTextLen,
  &_swigt__p_FIX__EncodedHeadline,
  &_swigt__p_FIX__EncodedHeadlineLen,
  &_swigt__p_FIX__EncodedIssuer,
  &_swigt__p_FIX__EncodedIssuerLen,
  &_swigt__p_FIX__EncodedLegIssuer,
  &_swigt__p_FIX__EncodedLegIssuerLen,
  &_swigt__p_FIX__EncodedLegSecurityDesc,
  &_swigt__p_FIX__EncodedLegSecurityDescLen,
  &_swigt__p_FIX__EncodedListExecInst,
  &_swigt__p_FIX__EncodedListExecInstLen,
  &_swigt__p_FIX__EncodedListStatusText,
  &_swigt__p_FIX__EncodedListStatusTextLen,
  &_swigt__p_FIX__EncodedMktSegmDesc,
  &_swigt__p_FIX__EncodedMktSegmDescLen,
  &_swigt__p_FIX__EncodedSecurityDesc,
  &_swigt__p_FIX__EncodedSecurityDescLen,
  &_swigt__p_FIX__EncodedSecurityListDesc,
  &_swigt__p_FIX__EncodedSecurityListDescLen,
  &_swigt__p_FIX__EncodedSubject,
  &_swigt__p_FIX__EncodedSubjectLen,
  &_swigt__p_FIX__EncodedText,
  &_swigt__p_FIX__EncodedTextLen,
  &_swigt__p_FIX__EncodedUnderlyingIssuer,
  &_swigt__p_FIX__EncodedUnderlyingIssuerLen,
  &_swigt__p_FIX__EncodedUnderlyingSecurityDesc,
  &_swigt__p_FIX__EncodedUnderlyingSecurityDescLen,
  &_swigt__p_FIX__EncryptMethod,
  &_swigt__p_FIX__EncryptedNewPassword,
  &_swigt__p_FIX__EncryptedNewPasswordLen,
  &_swigt__p_FIX__EncryptedPassword,
  &_swigt__p_FIX__EncryptedPasswordLen,
  &_swigt__p_FIX__EncryptedPasswordMethod,
  &_swigt__p_FIX__EndAccruedInterestAmt,
  &_swigt__p_FIX__EndCash,
  &_swigt__p_FIX__EndDate,
  &_swigt__p_FIX__EndMaturityMonthYear,
  &_swigt__p_FIX__EndSeqNo,
  &_swigt__p_FIX__EndStrikePxRange,
  &_swigt__p_FIX__EndTickPriceRange,
  &_swigt__p_FIX__EventDate,
  &_swigt__p_FIX__EventPx,
  &_swigt__p_FIX__EventText,
  &_swigt__p_FIX__EventTime,
  &_swigt__p_FIX__EventType,
  &_swigt__p_FIX__ExDate,
  &_swigt__p_FIX__ExDestination,
  &_swigt__p_FIX__ExDestinationIDSource,
  &_swigt__p_FIX__Exception,
  &_swigt__p_FIX__ExchangeForPhysical,
  &_swigt__p_FIX__ExchangeRule,
  &_swigt__p_FIX__ExchangeSpecialInstructions,
  &_swigt__p_FIX__ExecAckStatus,
  &_swigt__p_FIX__ExecBroker,
  &_swigt__p_FIX__ExecID,
  &_swigt__p_FIX__ExecInst,
  &_swigt__p_FIX__ExecInstValue,
  &_swigt__p_FIX__ExecPriceAdjustment,
  &_swigt__p_FIX__ExecPriceType,
  &_swigt__p_FIX__ExecRefID,
  &_swigt__p_FIX__ExecRestatementReason,
  &_swigt__p_FIX__ExecTransType,
  &_swigt__p_FIX__ExecType,
  &_swigt__p_FIX__ExecValuationPoint,
  &_swigt__p_FIX__ExerciseMethod,
  &_swigt__p_FIX__ExerciseStyle,
  &_swigt__p_FIX__ExpQty,
  &_swigt__p_FIX__ExpType,
  &_swigt__p_FIX__ExpirationCycle,
  &_swigt__p_FIX__ExpirationQtyType,
  &_swigt__p_FIX__ExpireDate,
  &_swigt__p_FIX__ExpireTime,
  &_swigt__p_FIX__FLOAT,
  &_swigt__p_FIX__Factor,
  &_swigt__p_FIX__FairValue,
  &_swigt__p_FIX__FeeMultiplier,
  &_swigt__p_FIX__FieldBase,
  &_swigt__p_FIX__FieldConvertError,
  &_swigt__p_FIX__FieldMap,
  &_swigt__p_FIX__FieldMap__Fields__const_iterator,
  &_swigt__p_FIX__FieldMap__Groups__const_iterator,
  &_swigt__p_FIX__FieldNotFound,
  &_swigt__p_FIX__FileLog,
  &_swigt__p_FIX__FileLogFactory,
  &_swigt__p_FIX__FileStore,
  &_swigt__p_FIX__FileStoreFactory,
  &_swigt__p_FIX__FillExecID,
  &_swigt__p_FIX__FillLiquidityInd,
  &_swigt__p_FIX__FillPx,
  &_swigt__p_FIX__FillQty,
  &_swigt__p_FIX__FinancialStatus,
  &_swigt__p_FIX__FirmTradeID,
  &_swigt__p_FIX__FirstPx,
  &_swigt__p_FIX__FlexProductEligibilityIndicator,
  &_swigt__p_FIX__FlexibleIndicator,
  &_swigt__p_FIX__FloorPrice,
  &_swigt__p_FIX__FlowScheduleType,
  &_swigt__p_FIX__ForexReq,
  &_swigt__p_FIX__FundRenewWaiv,
  &_swigt__p_FIX__FutSettDate,
  &_swigt__p_FIX__FutSettDate2,
  &_swigt__p_FIX__FuturesValuationMethod,
  &_swigt__p_FIX__GTBookingInst,
  &_swigt__p_FIX__GapFillFlag,
  &_swigt__p_FIX__GrossTradeAmt,
  &_swigt__p_FIX__Group,
  &_swigt__p_FIX__HaltReasonChar,
  &_swigt__p_FIX__HaltReasonInt,
  &_swigt__p_FIX__HandlInst,
  &_swigt__p_FIX__Header,
  &_swigt__p_FIX__Headline,
  &_swigt__p_FIX__HeartBtInt,
  &_swigt__p_FIX__HighLimitPrice,
  &_swigt__p_FIX__HighPx,
  &_swigt__p_FIX__HopCompID,
  &_swigt__p_FIX__HopRefID,
  &_swigt__p_FIX__HopSendingTime,
  &_swigt__p_FIX__HostCrossID,
  &_swigt__p_FIX__IDSource,
  &_swigt__p_FIX__INT,
  &_swigt__p_FIX__IOException,
  &_swigt__p_FIX__IOIID,
  &_swigt__p_FIX__IOINaturalFlag,
  &_swigt__p_FIX__IOIOthSvc,
  &_swigt__p_FIX__IOIQltyInd,
  &_swigt__p_FIX__IOIQty,
  &_swigt__p_FIX__IOIQualifier,
  &_swigt__p_FIX__IOIRefID,
  &_swigt__p_FIX__IOIShares,
  &_swigt__p_FIX__IOITransType,
  &_swigt__p_FIX__IOIid,
  &_swigt__p_FIX__ImpliedMarketIndicator,
  &_swigt__p_FIX__InViewOfCommon,
  &_swigt__p_FIX__IncTaxInd,
  &_swigt__p_FIX__IncorrectDataFormat,
  &_swigt__p_FIX__IncorrectMessageStructure,
  &_swigt__p_FIX__IncorrectTagValue,
  &_swigt__p_FIX__IndividualAllocID,
  &_swigt__p_FIX__IndividualAllocRejCode,
  &_swigt__p_FIX__IndividualAllocType,
  &_swigt__p_FIX__Initiator,
  &_swigt__p_FIX__InputSource,
  &_swigt__p_FIX__InstrAttribType,
  &_swigt__p_FIX__InstrAttribValue,
  &_swigt__p_FIX__InstrRegistry,
  &_swigt__p_FIX__InstrmtAssignmentMethod,
  &_swigt__p_FIX__InstrumentPartyID,
  &_swigt__p_FIX__InstrumentPartyIDSource,
  &_swigt__p_FIX__InstrumentPartyRole,
  &_swigt__p_FIX__InstrumentPartySubID,
  &_swigt__p_FIX__InstrumentPartySubIDType,
  &_swigt__p_FIX__IntField,
  &_swigt__p_FIX__InterestAccrualDate,
  &_swigt__p_FIX__InterestAtMaturity,
  &_swigt__p_FIX__InvalidMessage,
  &_swigt__p_FIX__InvalidMessageType,
  &_swigt__p_FIX__InvalidTagNumber,
  &_swigt__p_FIX__InvestorCountryOfResidence,
  &_swigt__p_FIX__IssueDate,
  &_swigt__p_FIX__Issuer,
  &_swigt__p_FIX__LANGUAGE,
  &_swigt__p_FIX__LENGTH,
  &_swigt__p_FIX__LOCALMKTDATE,
  &_swigt__p_FIX__LanguageCode,
  &_swigt__p_FIX__LastCapacity,
  &_swigt__p_FIX__LastForwardPoints,
  &_swigt__p_FIX__LastForwardPoints2,
  &_swigt__p_FIX__LastFragment,
  &_swigt__p_FIX__LastLiquidityInd,
  &_swigt__p_FIX__LastMkt,
  &_swigt__p_FIX__LastMsgSeqNumProcessed,
  &_swigt__p_FIX__LastNetworkResponseID,
  &_swigt__p_FIX__LastParPx,
  &_swigt__p_FIX__LastPx,
  &_swigt__p_FIX__LastQty,
  &_swigt__p_FIX__LastRptRequested,
  &_swigt__p_FIX__LastShares,
  &_swigt__p_FIX__LastSpotRate,
  &_swigt__p_FIX__LastSwapPoints,
  &_swigt__p_FIX__LastUpdateTime,
  &_swigt__p_FIX__LateIndicator,
  &_swigt__p_FIX__LeavesQty,
  &_swigt__p_FIX__LegAllocAccount,
  &_swigt__p_FIX__LegAllocAcctIDSource,
  &_swigt__p_FIX__LegAllocID,
  &_swigt__p_FIX__LegAllocQty,
  &_swigt__p_FIX__LegAllocSettlCurrency,
  &_swigt__p_FIX__LegBenchmarkCurveCurrency,
  &_swigt__p_FIX__LegBenchmarkCurveName,
  &_swigt__p_FIX__LegBenchmarkCurvePoint,
  &_swigt__p_FIX__LegBenchmarkPrice,
  &_swigt__p_FIX__LegBenchmarkPriceType,
  &_swigt__p_FIX__LegBidForwardPoints,
  &_swigt__p_FIX__LegBidPx,
  &_swigt__p_FIX__LegCFICode,
  &_swigt__p_FIX__LegCalculatedCcyLastQty,
  &_swigt__p_FIX__LegContractMultiplier,
  &_swigt__p_FIX__LegContractMultiplierUnit,
  &_swigt__p_FIX__LegContractSettlMonth,
  &_swigt__p_FIX__LegCountryOfIssue,
  &_swigt__p_FIX__LegCouponPaymentDate,
  &_swigt__p_FIX__LegCouponRate,
  &_swigt__p_FIX__LegCoveredOrUncovered,
  &_swigt__p_FIX__LegCreditRating,
  &_swigt__p_FIX__LegCurrency,
  &_swigt__p_FIX__LegCurrencyRatio,
  &_swigt__p_FIX__LegDatedDate,
  &_swigt__p_FIX__LegDividendYield,
  &_swigt__p_FIX__LegExecInst,
  &_swigt__p_FIX__LegExerciseStyle,
  &_swigt__p_FIX__LegFactor,
  &_swigt__p_FIX__LegFlowScheduleType,
  &_swigt__p_FIX__LegFutSettDate,
  &_swigt__p_FIX__LegGrossTradeAmt,
  &_swigt__p_FIX__LegIOIQty,
  &_swigt__p_FIX__LegIndividualAllocID,
  &_swigt__p_FIX__LegInstrRegistry,
  &_swigt__p_FIX__LegInterestAccrualDate,
  &_swigt__p_FIX__LegIssueDate,
  &_swigt__p_FIX__LegIssuer,
  &_swigt__p_FIX__LegLastForwardPoints,
  &_swigt__p_FIX__LegLastPx,
  &_swigt__p_FIX__LegLastQty,
  &_swigt__p_FIX__LegLocaleOfIssue,
  &_swigt__p_FIX__LegMaturityDate,
  &_swigt__p_FIX__LegMaturityMonthYear,
  &_swigt__p_FIX__LegMaturityTime,
  &_swigt__p_FIX__LegNumber,
  &_swigt__p_FIX__LegOfferForwardPoints,
  &_swigt__p_FIX__LegOfferPx,
  &_swigt__p_FIX__LegOptAttribute,
  &_swigt__p_FIX__LegOptionRatio,
  &_swigt__p_FIX__LegOrderQty,
  &_swigt__p_FIX__LegPool,
  &_swigt__p_FIX__LegPositionEffect,
  &_swigt__p_FIX__LegPrice,
  &_swigt__p_FIX__LegPriceType,
  &_swigt__p_FIX__LegPriceUnitOfMeasure,
  &_swigt__p_FIX__LegPriceUnitOfMeasureQty,
  &_swigt__p_FIX__LegProduct,
  &_swigt__p_FIX__LegPutOrCall,
  &_swigt__p_FIX__LegQty,
  &_swigt__p_FIX__LegRatioQty,
  &_swigt__p_FIX__LegRedemptionDate,
  &_swigt__p_FIX__LegRefID,
  &_swigt__p_FIX__LegRepoCollateralSecurityType,
  &_swigt__p_FIX__LegReportID,
  &_swigt__p_FIX__LegRepurchaseRate,
  &_swigt__p_FIX__LegRepurchaseTerm,
  &_swigt__p_FIX__LegSecurityAltID,
  &_swigt__p_FIX__LegSecurityAltIDSource,
  &_swigt__p_FIX__LegSecurityDesc,
  &_swigt__p_FIX__LegSecurityExchange,
  &_swigt__p_FIX__LegSecurityID,
  &_swigt__p_FIX__LegSecurityIDSource,
  &_swigt__p_FIX__LegSecuritySubType,
  &_swigt__p_FIX__LegSecurityType,
  &_swigt__p_FIX__LegSettlCurrency,
  &_swigt__p_FIX__LegSettlDate,
  &_swigt__p_FIX__LegSettlType,
  &_swigt__p_FIX__LegSettlmntTyp,
  &_swigt__p_FIX__LegSide,
  &_swigt__p_FIX__LegStateOrProvinceOfIssue,
  &_swigt__p_FIX__LegStipulationType,
  &_swigt__p_FIX__LegStipulationValue,
  &_swigt__p_FIX__LegStrikeCurrency,
  &_swigt__p_FIX__LegStrikePrice,
  &_swigt__p_FIX__LegSwapType,
  &_swigt__p_FIX__LegSymbol,
  &_swigt__p_FIX__LegSymbolSfx,
  &_swigt__p_FIX__LegTimeUnit,
  &_swigt__p_FIX__LegUnitOfMeasure,
  &_swigt__p_FIX__LegUnitOfMeasureQty,
  &_swigt__p_FIX__LegVolatility,
  &_swigt__p_FIX__LegalConfirm,
  &_swigt__p_FIX__LinesOfText,
  &_swigt__p_FIX__LiquidityIndType,
  &_swigt__p_FIX__LiquidityNumSecurities,
  &_swigt__p_FIX__LiquidityPctHigh,
  &_swigt__p_FIX__LiquidityPctLow,
  &_swigt__p_FIX__LiquidityValue,
  &_swigt__p_FIX__ListExecInst,
  &_swigt__p_FIX__ListExecInstType,
  &_swigt__p_FIX__ListID,
  &_swigt__p_FIX__ListMethod,
  &_swigt__p_FIX__ListName,
  &_swigt__p_FIX__ListNoOrds,
  &_swigt__p_FIX__ListOrderStatus,
  &_swigt__p_FIX__ListRejectReason,
  &_swigt__p_FIX__ListSeqNo,
  &_swigt__p_FIX__ListStatusText,
  &_swigt__p_FIX__ListStatusType,
  &_swigt__p_FIX__ListUpdateAction,
  &_swigt__p_FIX__LocaleOfIssue,
  &_swigt__p_FIX__LocateReqd,
  &_swigt__p_FIX__LocationID,
  &_swigt__p_FIX__Log,
  &_swigt__p_FIX__LogFactory,
  &_swigt__p_FIX__LongQty,
  &_swigt__p_FIX__LotType,
  &_swigt__p_FIX__LowLimitPrice,
  &_swigt__p_FIX__LowPx,
  &_swigt__p_FIX__MDBookType,
  &_swigt__p_FIX__MDEntryBuyer,
  &_swigt__p_FIX__MDEntryDate,
  &_swigt__p_FIX__MDEntryForwardPoints,
  &_swigt__p_FIX__MDEntryID,
  &_swigt__p_FIX__MDEntryOriginator,
  &_swigt__p_FIX__MDEntryPositionNo,
  &_swigt__p_FIX__MDEntryPx,
  &_swigt__p_FIX__MDEntryRefID,
  &_swigt__p_FIX__MDEntrySeller,
  &_swigt__p_FIX__MDEntrySize,
  &_swigt__p_FIX__MDEntrySpotRate,
  &_swigt__p_FIX__MDEntryTime,
  &_swigt__p_FIX__MDEntryType,
  &_swigt__p_FIX__MDFeedType,
  &_swigt__p_FIX__MDImplicitDelete,
  &_swigt__p_FIX__MDMkt,
  &_swigt__p_FIX__MDOriginType,
  &_swigt__p_FIX__MDPriceLevel,
  &_swigt__p_FIX__MDQuoteType,
  &_swigt__p_FIX__MDReportID,
  &_swigt__p_FIX__MDReqID,
  &_swigt__p_FIX__MDReqRejReason,
  &_swigt__p_FIX__MDSecSize,
  &_swigt__p_FIX__MDSecSizeType,
  &_swigt__p_FIX__MDStreamID,
  &_swigt__p_FIX__MDSubBookType,
  &_swigt__p_FIX__MDUpdateAction,
  &_swigt__p_FIX__MDUpdateType,
  &_swigt__p_FIX__MONTHYEAR,
  &_swigt__p_FIX__MULTIPLECHARVALUE,
  &_swigt__p_FIX__MULTIPLESTRINGVALUE,
  &_swigt__p_FIX__MULTIPLEVALUESTRING,
  &_swigt__p_FIX__MailingDtls,
  &_swigt__p_FIX__MailingInst,
  &_swigt__p_FIX__ManualOrderIndicator,
  &_swigt__p_FIX__MarginExcess,
  &_swigt__p_FIX__MarginRatio,
  &_swigt__p_FIX__MarketDepth,
  &_swigt__p_FIX__MarketID,
  &_swigt__p_FIX__MarketReportID,
  &_swigt__p_FIX__MarketReqID,
  &_swigt__p_FIX__MarketSegmentDesc,
  &_swigt__p_FIX__MarketSegmentID,
  &_swigt__p_FIX__MarketUpdateAction,
  &_swigt__p_FIX__MassActionRejectReason,
  &_swigt__p_FIX__MassActionReportID,
  &_swigt__p_FIX__MassActionResponse,
  &_swigt__p_FIX__MassActionScope,
  &_swigt__p_FIX__MassActionType,
  &_swigt__p_FIX__MassCancelRejectReason,
  &_swigt__p_FIX__MassCancelRequestType,
  &_swigt__p_FIX__MassCancelResponse,
  &_swigt__p_FIX__MassStatusReqID,
  &_swigt__p_FIX__MassStatusReqType,
  &_swigt__p_FIX__MatchAlgorithm,
  &_swigt__p_FIX__MatchIncrement,
  &_swigt__p_FIX__MatchStatus,
  &_swigt__p_FIX__MatchType,
  &_swigt__p_FIX__MaturityDate,
  &_swigt__p_FIX__MaturityDay,
  &_swigt__p_FIX__MaturityMonthYear,
  &_swigt__p_FIX__MaturityMonthYearFormat,
  &_swigt__p_FIX__MaturityMonthYearIncrement,
  &_swigt__p_FIX__MaturityMonthYearIncrementUnits,
  &_swigt__p_FIX__MaturityNetMoney,
  &_swigt__p_FIX__MaturityRuleID,
  &_swigt__p_FIX__MaturityTime,
  &_swigt__p_FIX__MaxFloor,
  &_swigt__p_FIX__MaxMessageSize,
  &_swigt__p_FIX__MaxPriceLevels,
  &_swigt__p_FIX__MaxPriceVariation,
  &_swigt__p_FIX__MaxShow,
  &_swigt__p_FIX__MaxTradeVol,
  &_swigt__p_FIX__MemoryStore,
  &_swigt__p_FIX__MemoryStoreFactory,
  &_swigt__p_FIX__Message,
  &_swigt__p_FIX__MessageEncoding,
  &_swigt__p_FIX__MessageEventSource,
  &_swigt__p_FIX__MessageParseError,
  &_swigt__p_FIX__MessageStore,
  &_swigt__p_FIX__MessageStoreExceptionWrapper,
  &_swigt__p_FIX__MessageStoreFactory,
  &_swigt__p_FIX__MessageStoreFactoryExceptionWrapper,
  &_swigt__p_FIX__MidPx,
  &_swigt__p_FIX__MidYield,
  &_swigt__p_FIX__MinBidSize,
  &_swigt__p_FIX__MinLotSize,
  &_swigt__p_FIX__MinOfferSize,
  &_swigt__p_FIX__MinPriceIncrement,
  &_swigt__p_FIX__MinPriceIncrementAmount,
  &_swigt__p_FIX__MinQty,
  &_swigt__p_FIX__MinTradeVol,
  &_swigt__p_FIX__MiscFeeAmt,
  &_swigt__p_FIX__MiscFeeBasis,
  &_swigt__p_FIX__MiscFeeCurr,
  &_swigt__p_FIX__MiscFeeType,
  &_swigt__p_FIX__MktBidPx,
  &_swigt__p_FIX__MktOfferPx,
  &_swigt__p_FIX__ModelType,
  &_swigt__p_FIX__MoneyLaunderingStatus,
  &_swigt__p_FIX__MsgDirection,
  &_swigt__p_FIX__MsgSeqNum,
  &_swigt__p_FIX__MsgType,
  &_swigt__p_FIX__MultiLegReportingType,
  &_swigt__p_FIX__MultiLegRptTypeReq,
  &_swigt__p_FIX__MultilegModel,
  &_swigt__p_FIX__MultilegPriceMethod,
  &_swigt__p_FIX__NTPositionLimit,
  &_swigt__p_FIX__NUMINGROUP,
  &_swigt__p_FIX__Nested2PartyID,
  &_swigt__p_FIX__Nested2PartyIDSource,
  &_swigt__p_FIX__Nested2PartyRole,
  &_swigt__p_FIX__Nested2PartySubID,
  &_swigt__p_FIX__Nested2PartySubIDType,
  &_swigt__p_FIX__Nested3PartyID,
  &_swigt__p_FIX__Nested3PartyIDSource,
  &_swigt__p_FIX__Nested3PartyRole,
  &_swigt__p_FIX__Nested3PartySubID,
  &_swigt__p_FIX__Nested3PartySubIDType,
  &_swigt__p_FIX__Nested4PartyID,
  &_swigt__p_FIX__Nested4PartyIDSource,
  &_swigt__p_FIX__Nested4PartyRole,
  &_swigt__p_FIX__Nested4PartySubID,
  &_swigt__p_FIX__Nested4PartySubIDType,
  &_swigt__p_FIX__NestedInstrAttribType,
  &_swigt__p_FIX__NestedInstrAttribValue,
  &_swigt__p_FIX__NestedPartyID,
  &_swigt__p_FIX__NestedPartyIDSource,
  &_swigt__p_FIX__NestedPartyRole,
  &_swigt__p_FIX__NestedPartySubID,
  &_swigt__p_FIX__NestedPartySubIDType,
  &_swigt__p_FIX__NetChgPrevDay,
  &_swigt__p_FIX__NetGrossInd,
  &_swigt__p_FIX__NetMoney,
  &_swigt__p_FIX__NetworkRequestID,
  &_swigt__p_FIX__NetworkRequestType,
  &_swigt__p_FIX__NetworkResponseID,
  &_swigt__p_FIX__NetworkStatusResponseType,
  &_swigt__p_FIX__NewPassword,
  &_swigt__p_FIX__NewSeqNo,
  &_swigt__p_FIX__NewsCategory,
  &_swigt__p_FIX__NewsID,
  &_swigt__p_FIX__NewsRefID,
  &_swigt__p_FIX__NewsRefType,
  &_swigt__p_FIX__NextExpectedMsgSeqNum,
  &_swigt__p_FIX__NoAffectedOrders,
  &_swigt__p_FIX__NoAllocs,
  &_swigt__p_FIX__NoAltMDSource,
  &_swigt__p_FIX__NoApplIDs,
  &_swigt__p_FIX__NoAsgnReqs,
  &_swigt__p_FIX__NoBidComponents,
  &_swigt__p_FIX__NoBidDescriptors,
  &_swigt__p_FIX__NoCapacities,
  &_swigt__p_FIX__NoClearingInstructions,
  &_swigt__p_FIX__NoCollInquiryQualifier,
  &_swigt__p_FIX__NoCompIDs,
  &_swigt__p_FIX__NoComplexEventDates,
  &_swigt__p_FIX__NoComplexEventTimes,
  &_swigt__p_FIX__NoComplexEvents,
  &_swigt__p_FIX__NoContAmts,
  &_swigt__p_FIX__NoContraBrokers,
  &_swigt__p_FIX__NoDates,
  &_swigt__p_FIX__NoDerivativeEvents,
  &_swigt__p_FIX__NoDerivativeInstrAttrib,
  &_swigt__p_FIX__NoDerivativeInstrumentParties,
  &_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs,
  &_swigt__p_FIX__NoDerivativeSecurityAltID,
  &_swigt__p_FIX__NoDistribInsts,
  &_swigt__p_FIX__NoDlvyInst,
  &_swigt__p_FIX__NoEvents,
  &_swigt__p_FIX__NoExecInstRules,
  &_swigt__p_FIX__NoExecs,
  &_swigt__p_FIX__NoExpiration,
  &_swigt__p_FIX__NoFills,
  &_swigt__p_FIX__NoHops,
  &_swigt__p_FIX__NoIOIQualifiers,
  &_swigt__p_FIX__NoInstrAttrib,
  &_swigt__p_FIX__NoInstrumentParties,
  &_swigt__p_FIX__NoInstrumentPartySubIDs,
  &_swigt__p_FIX__NoLegAllocs,
  &_swigt__p_FIX__NoLegSecurityAltID,
  &_swigt__p_FIX__NoLegStipulations,
  &_swigt__p_FIX__NoLegs,
  &_swigt__p_FIX__NoLinesOfText,
  &_swigt__p_FIX__NoLotTypeRules,
  &_swigt__p_FIX__NoMDEntries,
  &_swigt__p_FIX__NoMDEntryTypes,
  &_swigt__p_FIX__NoMDFeedTypes,
  &_swigt__p_FIX__NoMarketSegments,
  &_swigt__p_FIX__NoMatchRules,
  &_swigt__p_FIX__NoMaturityRules,
  &_swigt__p_FIX__NoMiscFees,
  &_swigt__p_FIX__NoMsgTypes,
  &_swigt__p_FIX__NoNested2PartyIDs,
  &_swigt__p_FIX__NoNested2PartySubIDs,
  &_swigt__p_FIX__NoNested3PartyIDs,
  &_swigt__p_FIX__NoNested3PartySubIDs,
  &_swigt__p_FIX__NoNested4PartyIDs,
  &_swigt__p_FIX__NoNested4PartySubIDs,
  &_swigt__p_FIX__NoNestedInstrAttrib,
  &_swigt__p_FIX__NoNestedPartyIDs,
  &_swigt__p_FIX__NoNestedPartySubIDs,
  &_swigt__p_FIX__NoNewsRefIDs,
  &_swigt__p_FIX__NoNotAffectedOrders,
  &_swigt__p_FIX__NoOfLegUnderlyings,
  &_swigt__p_FIX__NoOfSecSizes,
  &_swigt__p_FIX__NoOrdTypeRules,
  &_swigt__p_FIX__NoOrders,
  &_swigt__p_FIX__NoPartyIDs,
  &_swigt__p_FIX__NoPartySubIDs,
  &_swigt__p_FIX__NoPosAmt,
  &_swigt__p_FIX__NoPositions,
  &_swigt__p_FIX__NoQuoteEntries,
  &_swigt__p_FIX__NoQuoteQualifiers,
  &_swigt__p_FIX__NoQuoteSets,
  &_swigt__p_FIX__NoRateSources,
  &_swigt__p_FIX__NoRegistDtls,
  &_swigt__p_FIX__NoRelatedSym,
  &_swigt__p_FIX__NoRootPartyIDs,
  &_swigt__p_FIX__NoRootPartySubIDs,
  &_swigt__p_FIX__NoRoutingIDs,
  &_swigt__p_FIX__NoRpts,
  &_swigt__p_FIX__NoSecurityAltID,
  &_swigt__p_FIX__NoSecurityTypes,
  &_swigt__p_FIX__NoSettlDetails,
  &_swigt__p_FIX__NoSettlInst,
  &_swigt__p_FIX__NoSettlOblig,
  &_swigt__p_FIX__NoSettlPartyIDs,
  &_swigt__p_FIX__NoSettlPartySubIDs,
  &_swigt__p_FIX__NoSideTrdRegTS,
  &_swigt__p_FIX__NoSides,
  &_swigt__p_FIX__NoStatsIndicators,
  &_swigt__p_FIX__NoStipulations,
  &_swigt__p_FIX__NoStrategyParameters,
  &_swigt__p_FIX__NoStrikeRules,
  &_swigt__p_FIX__NoStrikes,
  &_swigt__p_FIX__NoTagValue,
  &_swigt__p_FIX__NoTargetPartyIDs,
  &_swigt__p_FIX__NoTickRules,
  &_swigt__p_FIX__NoTimeInForceRules,
  &_swigt__p_FIX__NoTrades,
  &_swigt__p_FIX__NoTradingSessionRules,
  &_swigt__p_FIX__NoTradingSessions,
  &_swigt__p_FIX__NoTrdRegTimestamps,
  &_swigt__p_FIX__NoTrdRepIndicators,
  &_swigt__p_FIX__NoUnderlyingAmounts,
  &_swigt__p_FIX__NoUnderlyingLegSecurityAltID,
  &_swigt__p_FIX__NoUnderlyingSecurityAltID,
  &_swigt__p_FIX__NoUnderlyingStips,
  &_swigt__p_FIX__NoUnderlyings,
  &_swigt__p_FIX__NoUndlyInstrumentParties,
  &_swigt__p_FIX__NoUndlyInstrumentPartySubIDs,
  &_swigt__p_FIX__NotAffOrigClOrdID,
  &_swigt__p_FIX__NotAffectedOrderID,
  &_swigt__p_FIX__NotifyBrokerOfCredit,
  &_swigt__p_FIX__NotionalPercentageOutstanding,
  &_swigt__p_FIX__NullApplication,
  &_swigt__p_FIX__NullLog,
  &_swigt__p_FIX__NumBidders,
  &_swigt__p_FIX__NumDaysInterest,
  &_swigt__p_FIX__NumTickets,
  &_swigt__p_FIX__NumberOfOrders,
  &_swigt__p_FIX__OddLot,
  &_swigt__p_FIX__OfferForwardPoints,
  &_swigt__p_FIX__OfferForwardPoints2,
  &_swigt__p_FIX__OfferPx,
  &_swigt__p_FIX__OfferSize,
  &_swigt__p_FIX__OfferSpotRate,
  &_swigt__p_FIX__OfferSwapPoints,
  &_swigt__p_FIX__OfferYield,
  &_swigt__p_FIX__OnBehalfOfCompID,
  &_swigt__p_FIX__OnBehalfOfLocationID,
  &_swigt__p_FIX__OnBehalfOfSendingTime,
  &_swigt__p_FIX__OnBehalfOfSubID,
  &_swigt__p_FIX__OpenClose,
  &_swigt__p_FIX__OpenCloseSettlFlag,
  &_swigt__p_FIX__OpenCloseSettleFlag,
  &_swigt__p_FIX__OpenInterest,
  &_swigt__p_FIX__OptAttribute,
  &_swigt__p_FIX__OptPayAmount,
  &_swigt__p_FIX__OptPayoutAmount,
  &_swigt__p_FIX__OptPayoutType,
  &_swigt__p_FIX__OrdRejReason,
  &_swigt__p_FIX__OrdStatus,
  &_swigt__p_FIX__OrdStatusReqID,
  &_swigt__p_FIX__OrdType,
  &_swigt__p_FIX__OrderAvgPx,
  &_swigt__p_FIX__OrderBookingQty,
  &_swigt__p_FIX__OrderCapacity,
  &_swigt__p_FIX__OrderCapacityQty,
  &_swigt__p_FIX__OrderCategory,
  &_swigt__p_FIX__OrderDelay,
  &_swigt__p_FIX__OrderDelayUnit,
  &_swigt__p_FIX__OrderHandlingInstSource,
  &_swigt__p_FIX__OrderID,
  &_swigt__p_FIX__OrderInputDevice,
  &_swigt__p_FIX__OrderPercent,
  &_swigt__p_FIX__OrderQty,
  &_swigt__p_FIX__OrderQty2,
  &_swigt__p_FIX__OrderRestrictions,
  &_swigt__p_FIX__OrigClOrdID,
  &_swigt__p_FIX__OrigCrossID,
  &_swigt__p_FIX__OrigCustOrderCapacity,
  &_swigt__p_FIX__OrigOrdModTime,
  &_swigt__p_FIX__OrigPosReqRefID,
  &_swigt__p_FIX__OrigSecondaryTradeID,
  &_swigt__p_FIX__OrigSendingTime,
  &_swigt__p_FIX__OrigTime,
  &_swigt__p_FIX__OrigTradeDate,
  &_swigt__p_FIX__OrigTradeHandlingInstr,
  &_swigt__p_FIX__OrigTradeID,
  &_swigt__p_FIX__OriginalNotionalPercentageOutstanding,
  &_swigt__p_FIX__OutMainCntryUIndex,
  &_swigt__p_FIX__OutsideIndexPct,
  &_swigt__p_FIX__OwnerType,
  &_swigt__p_FIX__OwnershipType,
  &_swigt__p_FIX__PERCENTAGE,
  &_swigt__p_FIX__PRICE,
  &_swigt__p_FIX__PRICEOFFSET,
  &_swigt__p_FIX__ParentMktSegmID,
  &_swigt__p_FIX__ParticipationRate,
  &_swigt__p_FIX__PartyID,
  &_swigt__p_FIX__PartyIDSource,
  &_swigt__p_FIX__PartyRole,
  &_swigt__p_FIX__PartySubID,
  &_swigt__p_FIX__PartySubIDType,
  &_swigt__p_FIX__Password,
  &_swigt__p_FIX__PaymentDate,
  &_swigt__p_FIX__PaymentMethod,
  &_swigt__p_FIX__PaymentRef,
  &_swigt__p_FIX__PaymentRemitterID,
  &_swigt__p_FIX__PctAtRisk,
  &_swigt__p_FIX__PegDifference,
  &_swigt__p_FIX__PegLimitType,
  &_swigt__p_FIX__PegMoveType,
  &_swigt__p_FIX__PegOffsetType,
  &_swigt__p_FIX__PegOffsetValue,
  &_swigt__p_FIX__PegPriceType,
  &_swigt__p_FIX__PegRoundDirection,
  &_swigt__p_FIX__PegScope,
  &_swigt__p_FIX__PegSecurityDesc,
  &_swigt__p_FIX__PegSecurityID,
  &_swigt__p_FIX__PegSecurityIDSource,
  &_swigt__p_FIX__PegSymbol,
  &_swigt__p_FIX__PeggedPrice,
  &_swigt__p_FIX__PeggedRefPrice,
  &_swigt__p_FIX__Pool,
  &_swigt__p_FIX__PosAmt,
  &_swigt__p_FIX__PosAmtType,
  &_swigt__p_FIX__PosMaintAction,
  &_swigt__p_FIX__PosMaintResult,
  &_swigt__p_FIX__PosMaintRptID,
  &_swigt__p_FIX__PosMaintRptRefID,
  &_swigt__p_FIX__PosMaintStatus,
  &_swigt__p_FIX__PosQtyStatus,
  &_swigt__p_FIX__PosReqID,
  &_swigt__p_FIX__PosReqResult,
  &_swigt__p_FIX__PosReqStatus,
  &_swigt__p_FIX__PosReqType,
  &_swigt__p_FIX__PosTransType,
  &_swigt__p_FIX__PosType,
  &_swigt__p_FIX__PositionCurrency,
  &_swigt__p_FIX__PositionEffect,
  &_swigt__p_FIX__PositionLimit,
  &_swigt__p_FIX__PossDupFlag,
  &_swigt__p_FIX__PossResend,
  &_swigt__p_FIX__PreTradeAnonymity,
  &_swigt__p_FIX__PreallocMethod,
  &_swigt__p_FIX__PrevClosePx,
  &_swigt__p_FIX__PreviouslyReported,
  &_swigt__p_FIX__Price,
  &_swigt__p_FIX__Price2,
  &_swigt__p_FIX__PriceDelta,
  &_swigt__p_FIX__PriceImprovement,
  &_swigt__p_FIX__PriceLimitType,
  &_swigt__p_FIX__PriceProtectionScope,
  &_swigt__p_FIX__PriceQuoteMethod,
  &_swigt__p_FIX__PriceType,
  &_swigt__p_FIX__PriceUnitOfMeasure,
  &_swigt__p_FIX__PriceUnitOfMeasureQty,
  &_swigt__p_FIX__PriorSettlPrice,
  &_swigt__p_FIX__PriorSpreadIndicator,
  &_swigt__p_FIX__PriorityIndicator,
  &_swigt__p_FIX__PrivateQuote,
  &_swigt__p_FIX__ProcessCode,
  &_swigt__p_FIX__Product,
  &_swigt__p_FIX__ProductComplex,
  &_swigt__p_FIX__ProgPeriodInterval,
  &_swigt__p_FIX__ProgRptReqs,
  &_swigt__p_FIX__PublishTrdIndicator,
  &_swigt__p_FIX__PutOrCall,
  &_swigt__p_FIX__QTY,
  &_swigt__p_FIX__QtyType,
  &_swigt__p_FIX__Quantity,
  &_swigt__p_FIX__QuantityDate,
  &_swigt__p_FIX__QuantityType,
  &_swigt__p_FIX__QuoteAckStatus,
  &_swigt__p_FIX__QuoteCancelType,
  &_swigt__p_FIX__QuoteCondition,
  &_swigt__p_FIX__QuoteEntryID,
  &_swigt__p_FIX__QuoteEntryRejectReason,
  &_swigt__p_FIX__QuoteEntryStatus,
  &_swigt__p_FIX__QuoteID,
  &_swigt__p_FIX__QuoteMsgID,
  &_swigt__p_FIX__QuotePriceType,
  &_swigt__p_FIX__QuoteQualifier,
  &_swigt__p_FIX__QuoteRejectReason,
  &_swigt__p_FIX__QuoteReqID,
  &_swigt__p_FIX__QuoteRequestRejectReason,
  &_swigt__p_FIX__QuoteRequestType,
  &_swigt__p_FIX__QuoteRespID,
  &_swigt__p_FIX__QuoteRespType,
  &_swigt__p_FIX__QuoteResponseLevel,
  &_swigt__p_FIX__QuoteSetID,
  &_swigt__p_FIX__QuoteSetValidUntilTime,
  &_swigt__p_FIX__QuoteStatus,
  &_swigt__p_FIX__QuoteStatusReqID,
  &_swigt__p_FIX__QuoteType,
  &_swigt__p_FIX__RFQReqID,
  &_swigt__p_FIX__RateSource,
  &_swigt__p_FIX__RateSourceType,
  &_swigt__p_FIX__RatioQty,
  &_swigt__p_FIX__RawData,
  &_swigt__p_FIX__RawDataLength,
  &_swigt__p_FIX__ReceivedDeptID,
  &_swigt__p_FIX__RedemptionDate,
  &_swigt__p_FIX__RefAllocID,
  &_swigt__p_FIX__RefApplExtID,
  &_swigt__p_FIX__RefApplID,
  &_swigt__p_FIX__RefApplLastSeqNum,
  &_swigt__p_FIX__RefApplReqID,
  &_swigt__p_FIX__RefApplVerID,
  &_swigt__p_FIX__RefCompID,
  &_swigt__p_FIX__RefCstmApplVerID,
  &_swigt__p_FIX__RefMsgType,
  &_swigt__p_FIX__RefOrdIDReason,
  &_swigt__p_FIX__RefOrderID,
  &_swigt__p_FIX__RefOrderIDSource,
  &_swigt__p_FIX__RefSeqNum,
  &_swigt__p_FIX__RefSubID,
  &_swigt__p_FIX__RefTagID,
  &_swigt__p_FIX__ReferencePage,
  &_swigt__p_FIX__RefreshIndicator,
  &_swigt__p_FIX__RefreshQty,
  &_swigt__p_FIX__RegistAcctType,
  &_swigt__p_FIX__RegistDetls,
  &_swigt__p_FIX__RegistDtls,
  &_swigt__p_FIX__RegistEmail,
  &_swigt__p_FIX__RegistID,
  &_swigt__p_FIX__RegistRefID,
  &_swigt__p_FIX__RegistRejReasonCode,
  &_swigt__p_FIX__RegistRejReasonText,
  &_swigt__p_FIX__RegistStatus,
  &_swigt__p_FIX__RegistTransType,
  &_swigt__p_FIX__RejectLogon,
  &_swigt__p_FIX__RejectText,
  &_swigt__p_FIX__RelSymTransactTime,
  &_swigt__p_FIX__RelatdSym,
  &_swigt__p_FIX__RepeatedTag,
  &_swigt__p_FIX__RepeatingGroupCountMismatch,
  &_swigt__p_FIX__RepoCollateralSecurityType,
  &_swigt__p_FIX__ReportToExch,
  &_swigt__p_FIX__ReportedPx,
  &_swigt__p_FIX__ReportedPxDiff,
  &_swigt__p_FIX__RepurchaseRate,
  &_swigt__p_FIX__RepurchaseTerm,
  &_swigt__p_FIX__RequiredTagMissing,
  &_swigt__p_FIX__ResetSeqNumFlag,
  &_swigt__p_FIX__RespondentType,
  &_swigt__p_FIX__ResponseDestination,
  &_swigt__p_FIX__ResponseTransportType,
  &_swigt__p_FIX__RestructuringType,
  &_swigt__p_FIX__ReversalIndicator,
  &_swigt__p_FIX__RiskFreeRate,
  &_swigt__p_FIX__RndPx,
  &_swigt__p_FIX__RootPartyID,
  &_swigt__p_FIX__RootPartyIDSource,
  &_swigt__p_FIX__RootPartyRole,
  &_swigt__p_FIX__RootPartySubID,
  &_swigt__p_FIX__RootPartySubIDType,
  &_swigt__p_FIX__RoundLot,
  &_swigt__p_FIX__RoundingDirection,
  &_swigt__p_FIX__RoundingModulus,
  &_swigt__p_FIX__RoutingID,
  &_swigt__p_FIX__RoutingType,
  &_swigt__p_FIX__RptSeq,
  &_swigt__p_FIX__RptSys,
  &_swigt__p_FIX__Rule80A,
  &_swigt__p_FIX__RuntimeError,
  &_swigt__p_FIX__SEQNUM,
  &_swigt__p_FIX__STRING,
  &_swigt__p_FIX__Scope,
  &_swigt__p_FIX__ScreenLog,
  &_swigt__p_FIX__ScreenLogFactory,
  &_swigt__p_FIX__SecondaryAllocID,
  &_swigt__p_FIX__SecondaryClOrdID,
  &_swigt__p_FIX__SecondaryDisplayQty,
  &_swigt__p_FIX__SecondaryExecID,
  &_swigt__p_FIX__SecondaryFirmTradeID,
  &_swigt__p_FIX__SecondaryHighLimitPrice,
  &_swigt__p_FIX__SecondaryIndividualAllocID,
  &_swigt__p_FIX__SecondaryLowLimitPrice,
  &_swigt__p_FIX__SecondaryOrderID,
  &_swigt__p_FIX__SecondaryPriceLimitType,
  &_swigt__p_FIX__SecondaryTradeID,
  &_swigt__p_FIX__SecondaryTradeReportID,
  &_swigt__p_FIX__SecondaryTradeReportRefID,
  &_swigt__p_FIX__SecondaryTradingReferencePrice,
  &_swigt__p_FIX__SecondaryTrdType,
  &_swigt__p_FIX__SecureData,
  &_swigt__p_FIX__SecureDataLen,
  &_swigt__p_FIX__SecurityAltID,
  &_swigt__p_FIX__SecurityAltIDSource,
  &_swigt__p_FIX__SecurityDesc,
  &_swigt__p_FIX__SecurityExchange,
  &_swigt__p_FIX__SecurityGroup,
  &_swigt__p_FIX__SecurityID,
  &_swigt__p_FIX__SecurityIDSource,
  &_swigt__p_FIX__SecurityListDesc,
  &_swigt__p_FIX__SecurityListID,
  &_swigt__p_FIX__SecurityListRefID,
  &_swigt__p_FIX__SecurityListRequestType,
  &_swigt__p_FIX__SecurityListType,
  &_swigt__p_FIX__SecurityListTypeSource,
  &_swigt__p_FIX__SecurityReportID,
  &_swigt__p_FIX__SecurityReqID,
  &_swigt__p_FIX__SecurityRequestResult,
  &_swigt__p_FIX__SecurityRequestType,
  &_swigt__p_FIX__SecurityResponseID,
  &_swigt__p_FIX__SecurityResponseType,
  &_swigt__p_FIX__SecuritySettlAgentAcctName,
  &_swigt__p_FIX__SecuritySettlAgentAcctNum,
  &_swigt__p_FIX__SecuritySettlAgentCode,
  &_swigt__p_FIX__SecuritySettlAgentContactName,
  &_swigt__p_FIX__SecuritySettlAgentContactPhone,
  &_swigt__p_FIX__SecuritySettlAgentName,
  &_swigt__p_FIX__SecurityStatus,
  &_swigt__p_FIX__SecurityStatusReqID,
  &_swigt__p_FIX__SecuritySubType,
  &_swigt__p_FIX__SecurityTradingEvent,
  &_swigt__p_FIX__SecurityTradingStatus,
  &_swigt__p_FIX__SecurityType,
  &_swigt__p_FIX__SecurityUpdateAction,
  &_swigt__p_FIX__SecurityXML,
  &_swigt__p_FIX__SecurityXMLLen,
  &_swigt__p_FIX__SecurityXMLSchema,
  &_swigt__p_FIX__SellVolume,
  &_swigt__p_FIX__SellerDays,
  &_swigt__p_FIX__SenderCompID,
  &_swigt__p_FIX__SenderLocationID,
  &_swigt__p_FIX__SenderSubID,
  &_swigt__p_FIX__SendingDate,
  &_swigt__p_FIX__SendingTime,
  &_swigt__p_FIX__Seniority,
  &_swigt__p_FIX__Session,
  &_swigt__p_FIX__SessionID,
  &_swigt__p_FIX__SessionNotFound,
  &_swigt__p_FIX__SessionRejectReason,
  &_swigt__p_FIX__SessionSettings,
  &_swigt__p_FIX__SessionStatus,
  &_swigt__p_FIX__SettlBrkrCode,
  &_swigt__p_FIX__SettlCurrAmt,
  &_swigt__p_FIX__SettlCurrBidFxRate,
  &_swigt__p_FIX__SettlCurrFxRate,
  &_swigt__p_FIX__SettlCurrFxRateCalc,
  &_swigt__p_FIX__SettlCurrOfferFxRate,
  &_swigt__p_FIX__SettlCurrency,
  &_swigt__p_FIX__SettlDate,
  &_swigt__p_FIX__SettlDate2,
  &_swigt__p_FIX__SettlDeliveryType,
  &_swigt__p_FIX__SettlDepositoryCode,
  &_swigt__p_FIX__SettlInstCode,
  &_swigt__p_FIX__SettlInstID,
  &_swigt__p_FIX__SettlInstMode,
  &_swigt__p_FIX__SettlInstMsgID,
  &_swigt__p_FIX__SettlInstRefID,
  &_swigt__p_FIX__SettlInstReqID,
  &_swigt__p_FIX__SettlInstReqRejCode,
  &_swigt__p_FIX__SettlInstSource,
  &_swigt__p_FIX__SettlInstTransType,
  &_swigt__p_FIX__SettlLocation,
  &_swigt__p_FIX__SettlMethod,
  &_swigt__p_FIX__SettlObligID,
  &_swigt__p_FIX__SettlObligMode,
  &_swigt__p_FIX__SettlObligMsgID,
  &_swigt__p_FIX__SettlObligRefID,
  &_swigt__p_FIX__SettlObligSource,
  &_swigt__p_FIX__SettlObligTransType,
  &_swigt__p_FIX__SettlPartyID,
  &_swigt__p_FIX__SettlPartyIDSource,
  &_swigt__p_FIX__SettlPartyRole,
  &_swigt__p_FIX__SettlPartySubID,
  &_swigt__p_FIX__SettlPartySubIDType,
  &_swigt__p_FIX__SettlPrice,
  &_swigt__p_FIX__SettlPriceType,
  &_swigt__p_FIX__SettlSessID,
  &_swigt__p_FIX__SettlSessSubID,
  &_swigt__p_FIX__SettlType,
  &_swigt__p_FIX__SettleOnOpenFlag,
  &_swigt__p_FIX__SettlementCycleNo,
  &_swigt__p_FIX__SettlmntTyp,
  &_swigt__p_FIX__SharedCommission,
  &_swigt__p_FIX__Shares,
  &_swigt__p_FIX__ShortQty,
  &_swigt__p_FIX__ShortSaleReason,
  &_swigt__p_FIX__Side,
  &_swigt__p_FIX__SideComplianceID,
  &_swigt__p_FIX__SideCurrency,
  &_swigt__p_FIX__SideExecID,
  &_swigt__p_FIX__SideFillStationCd,
  &_swigt__p_FIX__SideGrossTradeAmt,
  &_swigt__p_FIX__SideLastQty,
  &_swigt__p_FIX__SideLiquidityInd,
  &_swigt__p_FIX__SideMultiLegReportingType,
  &_swigt__p_FIX__SideQty,
  &_swigt__p_FIX__SideReasonCd,
  &_swigt__p_FIX__SideSettlCurrency,
  &_swigt__p_FIX__SideTimeInForce,
  &_swigt__p_FIX__SideTradeReportID,
  &_swigt__p_FIX__SideTrdRegTimestamp,
  &_swigt__p_FIX__SideTrdRegTimestampSrc,
  &_swigt__p_FIX__SideTrdRegTimestampType,
  &_swigt__p_FIX__SideTrdSubTyp,
  &_swigt__p_FIX__SideValue1,
  &_swigt__p_FIX__SideValue2,
  &_swigt__p_FIX__SideValueInd,
  &_swigt__p_FIX__Signature,
  &_swigt__p_FIX__SignatureLength,
  &_swigt__p_FIX__SocketAcceptor,
  &_swigt__p_FIX__SocketCloseFailed,
  &_swigt__p_FIX__SocketException,
  &_swigt__p_FIX__SocketInitiator,
  &_swigt__p_FIX__SocketRecvFailed,
  &_swigt__p_FIX__SocketSendFailed,
  &_swigt__p_FIX__SolicitedFlag,
  &_swigt__p_FIX__Spread,
  &_swigt__p_FIX__SpreadToBenchmark,
  &_swigt__p_FIX__StandInstDbID,
  &_swigt__p_FIX__StandInstDbName,
  &_swigt__p_FIX__StandInstDbType,
  &_swigt__p_FIX__StartCash,
  &_swigt__p_FIX__StartDate,
  &_swigt__p_FIX__StartMaturityMonthYear,
  &_swigt__p_FIX__StartStrikePxRange,
  &_swigt__p_FIX__StartTickPriceRange,
  &_swigt__p_FIX__StateOrProvinceOfIssue,
  &_swigt__p_FIX__StatsType,
  &_swigt__p_FIX__StatusText,
  &_swigt__p_FIX__StatusValue,
  &_swigt__p_FIX__StipulationType,
  &_swigt__p_FIX__StipulationValue,
  &_swigt__p_FIX__StopPx,
  &_swigt__p_FIX__StrategyParameterName,
  &_swigt__p_FIX__StrategyParameterType,
  &_swigt__p_FIX__StrategyParameterValue,
  &_swigt__p_FIX__StreamAsgnAckType,
  &_swigt__p_FIX__StreamAsgnRejReason,
  &_swigt__p_FIX__StreamAsgnReqID,
  &_swigt__p_FIX__StreamAsgnReqType,
  &_swigt__p_FIX__StreamAsgnRptID,
  &_swigt__p_FIX__StreamAsgnType,
  &_swigt__p_FIX__StrikeCurrency,
  &_swigt__p_FIX__StrikeExerciseStyle,
  &_swigt__p_FIX__StrikeIncrement,
  &_swigt__p_FIX__StrikeMultiplier,
  &_swigt__p_FIX__StrikePrice,
  &_swigt__p_FIX__StrikePriceBoundaryMethod,
  &_swigt__p_FIX__StrikePriceBoundaryPrecision,
  &_swigt__p_FIX__StrikePriceDeterminationMethod,
  &_swigt__p_FIX__StrikeRuleID,
  &_swigt__p_FIX__StrikeTime,
  &_swigt__p_FIX__StrikeValue,
  &_swigt__p_FIX__StringField,
  &_swigt__p_FIX__Subject,
  &_swigt__p_FIX__SubscriptionRequestType,
  &_swigt__p_FIX__SwapPoints,
  &_swigt__p_FIX__Symbol,
  &_swigt__p_FIX__SymbolSfx,
  &_swigt__p_FIX__SynchronizedApplication,
  &_swigt__p_FIX__TYPE__Type,
  &_swigt__p_FIX__TZTIMEONLY,
  &_swigt__p_FIX__TZTIMESTAMP,
  &_swigt__p_FIX__TZTransactTime,
  &_swigt__p_FIX__TagNotDefinedForMessage,
  &_swigt__p_FIX__TagOutOfOrder,
  &_swigt__p_FIX__TargetCompID,
  &_swigt__p_FIX__TargetLocationID,
  &_swigt__p_FIX__TargetPartyID,
  &_swigt__p_FIX__TargetPartyIDSource,
  &_swigt__p_FIX__TargetPartyRole,
  &_swigt__p_FIX__TargetStrategy,
  &_swigt__p_FIX__TargetStrategyParameters,
  &_swigt__p_FIX__TargetStrategyPerformance,
  &_swigt__p_FIX__TargetSubID,
  &_swigt__p_FIX__TaxAdvantageType,
  &_swigt__p_FIX__TerminationType,
  &_swigt__p_FIX__TestMessageIndicator,
  &_swigt__p_FIX__TestReqID,
  &_swigt__p_FIX__Text,
  &_swigt__p_FIX__ThresholdAmount,
  &_swigt__p_FIX__TickDirection,
  &_swigt__p_FIX__TickIncrement,
  &_swigt__p_FIX__TickRuleType,
  &_swigt__p_FIX__TierCode,
  &_swigt__p_FIX__TimeBracket,
  &_swigt__p_FIX__TimeInForce,
  &_swigt__p_FIX__TimeToExpiration,
  &_swigt__p_FIX__TimeUnit,
  &_swigt__p_FIX__TotNoAccQuotes,
  &_swigt__p_FIX__TotNoAllocs,
  &_swigt__p_FIX__TotNoCxldQuotes,
  &_swigt__p_FIX__TotNoFills,
  &_swigt__p_FIX__TotNoOrders,
  &_swigt__p_FIX__TotNoQuoteEntries,
  &_swigt__p_FIX__TotNoRejQuotes,
  &_swigt__p_FIX__TotNoRelatedSym,
  &_swigt__p_FIX__TotNoSecurityTypes,
  &_swigt__p_FIX__TotNoStrikes,
  &_swigt__p_FIX__TotNumAssignmentReports,
  &_swigt__p_FIX__TotNumReports,
  &_swigt__p_FIX__TotNumTradeReports,
  &_swigt__p_FIX__TotQuoteEntries,
  &_swigt__p_FIX__TotalAccruedInterestAmt,
  &_swigt__p_FIX__TotalAffectedOrders,
  &_swigt__p_FIX__TotalNetValue,
  &_swigt__p_FIX__TotalNumPosReports,
  &_swigt__p_FIX__TotalNumSecurities,
  &_swigt__p_FIX__TotalNumSecurityTypes,
  &_swigt__p_FIX__TotalTakedown,
  &_swigt__p_FIX__TotalVolumeTraded,
  &_swigt__p_FIX__TotalVolumeTradedDate,
  &_swigt__p_FIX__TotalVolumeTradedTime,
  &_swigt__p_FIX__TradSesCloseTime,
  &_swigt__p_FIX__TradSesEndTime,
  &_swigt__p_FIX__TradSesEvent,
  &_swigt__p_FIX__TradSesMethod,
  &_swigt__p_FIX__TradSesMode,
  &_swigt__p_FIX__TradSesOpenTime,
  &_swigt__p_FIX__TradSesPreCloseTime,
  &_swigt__p_FIX__TradSesReqID,
  &_swigt__p_FIX__TradSesStartTime,
  &_swigt__p_FIX__TradSesStatus,
  &_swigt__p_FIX__TradSesStatusRejReason,
  &_swigt__p_FIX__TradSesUpdateAction,
  &_swigt__p_FIX__TradeAllocIndicator,
  &_swigt__p_FIX__TradeCondition,
  &_swigt__p_FIX__TradeDate,
  &_swigt__p_FIX__TradeHandlingInstr,
  &_swigt__p_FIX__TradeID,
  &_swigt__p_FIX__TradeInputDevice,
  &_swigt__p_FIX__TradeInputSource,
  &_swigt__p_FIX__TradeLegRefID,
  &_swigt__p_FIX__TradeLinkID,
  &_swigt__p_FIX__TradeOriginationDate,
  &_swigt__p_FIX__TradePublishIndicator,
  &_swigt__p_FIX__TradeReportID,
  &_swigt__p_FIX__TradeReportRefID,
  &_swigt__p_FIX__TradeReportRejectReason,
  &_swigt__p_FIX__TradeReportTransType,
  &_swigt__p_FIX__TradeReportType,
  &_swigt__p_FIX__TradeRequestID,
  &_swigt__p_FIX__TradeRequestResult,
  &_swigt__p_FIX__TradeRequestStatus,
  &_swigt__p_FIX__TradeRequestType,
  &_swigt__p_FIX__TradeType,
  &_swigt__p_FIX__TradeVolume,
  &_swigt__p_FIX__TradedFlatSwitch,
  &_swigt__p_FIX__TradingCurrency,
  &_swigt__p_FIX__TradingReferencePrice,
  &_swigt__p_FIX__TradingSessionDesc,
  &_swigt__p_FIX__TradingSessionID,
  &_swigt__p_FIX__TradingSessionSubID,
  &_swigt__p_FIX__Trailer,
  &_swigt__p_FIX__TransBkdTime,
  &_swigt__p_FIX__TransactTime,
  &_swigt__p_FIX__TransferReason,
  &_swigt__p_FIX__TrdMatchID,
  &_swigt__p_FIX__TrdRegTimestamp,
  &_swigt__p_FIX__TrdRegTimestampOrigin,
  &_swigt__p_FIX__TrdRegTimestampType,
  &_swigt__p_FIX__TrdRepIndicator,
  &_swigt__p_FIX__TrdRepPartyRole,
  &_swigt__p_FIX__TrdRptStatus,
  &_swigt__p_FIX__TrdSubType,
  &_swigt__p_FIX__TrdType,
  &_swigt__p_FIX__TriggerAction,
  &_swigt__p_FIX__TriggerNewPrice,
  &_swigt__p_FIX__TriggerNewQty,
  &_swigt__p_FIX__TriggerOrderType,
  &_swigt__p_FIX__TriggerPrice,
  &_swigt__p_FIX__TriggerPriceDirection,
  &_swigt__p_FIX__TriggerPriceType,
  &_swigt__p_FIX__TriggerPriceTypeScope,
  &_swigt__p_FIX__TriggerSecurityDesc,
  &_swigt__p_FIX__TriggerSecurityID,
  &_swigt__p_FIX__TriggerSecurityIDSource,
  &_swigt__p_FIX__TriggerSymbol,
  &_swigt__p_FIX__TriggerTradingSessionID,
  &_swigt__p_FIX__TriggerTradingSessionSubID,
  &_swigt__p_FIX__TriggerType,
  &_swigt__p_FIX__URLLink,
  &_swigt__p_FIX__UTCDATE,
  &_swigt__p_FIX__UTCDATEONLY,
  &_swigt__p_FIX__UTCTIMEONLY,
  &_swigt__p_FIX__UTCTIMESTAMP,
  &_swigt__p_FIX__UnderlyingAdjustedQuantity,
  &_swigt__p_FIX__UnderlyingAllocationPercent,
  &_swigt__p_FIX__UnderlyingAttachmentPoint,
  &_swigt__p_FIX__UnderlyingCFICode,
  &_swigt__p_FIX__UnderlyingCPProgram,
  &_swigt__p_FIX__UnderlyingCPRegType,
  &_swigt__p_FIX__UnderlyingCapValue,
  &_swigt__p_FIX__UnderlyingCashAmount,
  &_swigt__p_FIX__UnderlyingCashType,
  &_swigt__p_FIX__UnderlyingCollectAmount,
  &_swigt__p_FIX__UnderlyingContractMultiplier,
  &_swigt__p_FIX__UnderlyingContractMultiplierUnit,
  &_swigt__p_FIX__UnderlyingCountryOfIssue,
  &_swigt__p_FIX__UnderlyingCouponPaymentDate,
  &_swigt__p_FIX__UnderlyingCouponRate,
  &_swigt__p_FIX__UnderlyingCreditRating,
  &_swigt__p_FIX__UnderlyingCurrency,
  &_swigt__p_FIX__UnderlyingCurrentValue,
  &_swigt__p_FIX__UnderlyingDeliveryAmount,
  &_swigt__p_FIX__UnderlyingDetachmentPoint,
  &_swigt__p_FIX__UnderlyingDirtyPrice,
  &_swigt__p_FIX__UnderlyingEndPrice,
  &_swigt__p_FIX__UnderlyingEndValue,
  &_swigt__p_FIX__UnderlyingExerciseStyle,
  &_swigt__p_FIX__UnderlyingFXRate,
  &_swigt__p_FIX__UnderlyingFXRateCalc,
  &_swigt__p_FIX__UnderlyingFactor,
  &_swigt__p_FIX__UnderlyingFlowScheduleType,
  &_swigt__p_FIX__UnderlyingIDSource,
  &_swigt__p_FIX__UnderlyingInstrRegistry,
  &_swigt__p_FIX__UnderlyingInstrumentPartyID,
  &_swigt__p_FIX__UnderlyingInstrumentPartyIDSource,
  &_swigt__p_FIX__UnderlyingInstrumentPartyRole,
  &_swigt__p_FIX__UnderlyingInstrumentPartySubID,
  &_swigt__p_FIX__UnderlyingInstrumentPartySubIDType,
  &_swigt__p_FIX__UnderlyingIssueDate,
  &_swigt__p_FIX__UnderlyingIssuer,
  &_swigt__p_FIX__UnderlyingLastPx,
  &_swigt__p_FIX__UnderlyingLastQty,
  &_swigt__p_FIX__UnderlyingLegCFICode,
  &_swigt__p_FIX__UnderlyingLegMaturityDate,
  &_swigt__p_FIX__UnderlyingLegMaturityMonthYear,
  &_swigt__p_FIX__UnderlyingLegMaturityTime,
  &_swigt__p_FIX__UnderlyingLegOptAttribute,
  &_swigt__p_FIX__UnderlyingLegPutOrCall,
  &_swigt__p_FIX__UnderlyingLegSecurityAltID,
  &_swigt__p_FIX__UnderlyingLegSecurityAltIDSource,
  &_swigt__p_FIX__UnderlyingLegSecurityDesc,
  &_swigt__p_FIX__UnderlyingLegSecurityExchange,
  &_swigt__p_FIX__UnderlyingLegSecurityID,
  &_swigt__p_FIX__UnderlyingLegSecurityIDSource,
  &_swigt__p_FIX__UnderlyingLegSecuritySubType,
  &_swigt__p_FIX__UnderlyingLegSecurityType,
  &_swigt__p_FIX__UnderlyingLegStrikePrice,
  &_swigt__p_FIX__UnderlyingLegSymbol,
  &_swigt__p_FIX__UnderlyingLegSymbolSfx,
  &_swigt__p_FIX__UnderlyingLocaleOfIssue,
  &_swigt__p_FIX__UnderlyingMaturityDate,
  &_swigt__p_FIX__UnderlyingMaturityDay,
  &_swigt__p_FIX__UnderlyingMaturityMonthYear,
  &_swigt__p_FIX__UnderlyingMaturityTime,
  &_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding,
  &_swigt__p_FIX__UnderlyingOptAttribute,
  &_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding,
  &_swigt__p_FIX__UnderlyingPayAmount,
  &_swigt__p_FIX__UnderlyingPriceDeterminationMethod,
  &_swigt__p_FIX__UnderlyingPriceUnitOfMeasure,
  &_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty,
  &_swigt__p_FIX__UnderlyingProduct,
  &_swigt__p_FIX__UnderlyingPutOrCall,
  &_swigt__p_FIX__UnderlyingPx,
  &_swigt__p_FIX__UnderlyingQty,
  &_swigt__p_FIX__UnderlyingRedemptionDate,
  &_swigt__p_FIX__UnderlyingRepoCollateralSecurityType,
  &_swigt__p_FIX__UnderlyingRepurchaseRate,
  &_swigt__p_FIX__UnderlyingRepurchaseTerm,
  &_swigt__p_FIX__UnderlyingRestructuringType,
  &_swigt__p_FIX__UnderlyingSecurityAltID,
  &_swigt__p_FIX__UnderlyingSecurityAltIDSource,
  &_swigt__p_FIX__UnderlyingSecurityDesc,
  &_swigt__p_FIX__UnderlyingSecurityExchange,
  &_swigt__p_FIX__UnderlyingSecurityID,
  &_swigt__p_FIX__UnderlyingSecurityIDSource,
  &_swigt__p_FIX__UnderlyingSecuritySubType,
  &_swigt__p_FIX__UnderlyingSecurityType,
  &_swigt__p_FIX__UnderlyingSeniority,
  &_swigt__p_FIX__UnderlyingSettlMethod,
  &_swigt__p_FIX__UnderlyingSettlPrice,
  &_swigt__p_FIX__UnderlyingSettlPriceType,
  &_swigt__p_FIX__UnderlyingSettlementDate,
  &_swigt__p_FIX__UnderlyingSettlementStatus,
  &_swigt__p_FIX__UnderlyingSettlementType,
  &_swigt__p_FIX__UnderlyingStartValue,
  &_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue,
  &_swigt__p_FIX__UnderlyingStipType,
  &_swigt__p_FIX__UnderlyingStipValue,
  &_swigt__p_FIX__UnderlyingStrikeCurrency,
  &_swigt__p_FIX__UnderlyingStrikePrice,
  &_swigt__p_FIX__UnderlyingSymbol,
  &_swigt__p_FIX__UnderlyingSymbolSfx,
  &_swigt__p_FIX__UnderlyingTimeUnit,
  &_swigt__p_FIX__UnderlyingTradingSessionID,
  &_swigt__p_FIX__UnderlyingTradingSessionSubID,
  &_swigt__p_FIX__UnderlyingUnitOfMeasure,
  &_swigt__p_FIX__UnderlyingUnitOfMeasureQty,
  &_swigt__p_FIX__UndlyInstrumentPartyID,
  &_swigt__p_FIX__UndlyInstrumentPartyIDSource,
  &_swigt__p_FIX__UndlyInstrumentPartyRole,
  &_swigt__p_FIX__UndlyInstrumentPartySubID,
  &_swigt__p_FIX__UndlyInstrumentPartySubIDType,
  &_swigt__p_FIX__UnitOfMeasure,
  &_swigt__p_FIX__UnitOfMeasureQty,
  &_swigt__p_FIX__UnsolicitedIndicator,
  &_swigt__p_FIX__UnsupportedMessageType,
  &_swigt__p_FIX__UnsupportedVersion,
  &_swigt__p_FIX__Urgency,
  &_swigt__p_FIX__UserRequestID,
  &_swigt__p_FIX__UserRequestType,
  &_swigt__p_FIX__UserStatus,
  &_swigt__p_FIX__UserStatusText,
  &_swigt__p_FIX__Username,
  &_swigt__p_FIX__UtcDateField,
  &_swigt__p_FIX__UtcTimeOnlyField,
  &_swigt__p_FIX__UtcTimeStampField,
  &_swigt__p_FIX__ValidUntilTime,
  &_swigt__p_FIX__ValuationMethod,
  &_swigt__p_FIX__ValueOfFutures,
  &_swigt__p_FIX__VenueType,
  &_swigt__p_FIX__Volatility,
  &_swigt__p_FIX__WaveNo,
  &_swigt__p_FIX__WorkingIndicator,
  &_swigt__p_FIX__WtAverageLiquidity,
  &_swigt__p_FIX__XMLDATA,
  &_swigt__p_FIX__XmlData,
  &_swigt__p_FIX__XmlDataLen,
  &_swigt__p_FIX__Yield,
  &_swigt__p_FIX__YieldCalcDate,
  &_swigt__p_FIX__YieldRedemptionDate,
  &_swigt__p_FIX__YieldRedemptionPrice,
  &_swigt__p_FIX__YieldRedemptionPriceType,
  &_swigt__p_FIX__YieldType,
  &_swigt__p_Fields,
  &_swigt__p_Group,
  &_swigt__p_Groups,
  &_swigt__p_IntArray,
  &_swigt__p_IntField,
  &_swigt__p_Log,
  &_swigt__p_LogFactory,
  &_swigt__p_MessageStore,
  &_swigt__p_MessageStoreFactory,
  &_swigt__p_MsgType,
  &_swigt__p_Mutex,
  &_swigt__p_Responder,
  &_swigt__p_SessionID,
  &_swigt__p_StringField,
  &_swigt__p_TimeRange,
  &_swigt__p_UtcDate,
  &_swigt__p_UtcDateField,
  &_swigt__p_UtcTimeOnly,
  &_swigt__p_UtcTimeStamp,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_const_iterator,
  &_swigt__p_g_const_iterator,
  &_swigt__p_g_iterator,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_message_order,
  &_swigt__p_p_FIX__DataDictionary,
  &_swigt__p_std__istream,
  &_swigt__p_std__ostream,
  &_swigt__p_std__setT_FIX__SessionID_t,
  &_swigt__p_std__string,
  &_swigt__p_std__string__size_type,
  &_swigt__p_std__vectorT_std__string_t,
};

static swig_cast_info _swigc__p_ApplVerID[] = {  {&_swigt__p_ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Application[] = {  {&_swigt__p_Application, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BeginString[] = {  {&_swigt__p_BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DOMDocumentPtr[] = {  {&_swigt__p_DOMDocumentPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Data[] = {  {&_swigt__p_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionary[] = {  {&_swigt__p_DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionaryProvider[] = {  {&_swigt__p_DataDictionaryProvider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dictionaries[] = {  {&_swigt__p_Dictionaries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DoubleField[] = {  {&_swigt__p_DoubleField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AMT[] = {  {&_swigt__p_FIX__AMT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Acceptor[] = {  {&_swigt__p_FIX__Acceptor, 0, 0, 0},  {&_swigt__p_FIX__SocketAcceptor, _p_FIX__SocketAcceptorTo_p_FIX__Acceptor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Account[] = {  {&_swigt__p_FIX__Account, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccountType[] = {  {&_swigt__p_FIX__AccountType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccruedInterestAmt[] = {  {&_swigt__p_FIX__AccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccruedInterestRate[] = {  {&_swigt__p_FIX__AccruedInterestRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AcctIDSource[] = {  {&_swigt__p_FIX__AcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Adjustment[] = {  {&_swigt__p_FIX__Adjustment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdjustmentType[] = {  {&_swigt__p_FIX__AdjustmentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvId[] = {  {&_swigt__p_FIX__AdvId, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvRefID[] = {  {&_swigt__p_FIX__AdvRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvSide[] = {  {&_swigt__p_FIX__AdvSide, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvTransType[] = {  {&_swigt__p_FIX__AdvTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffectedOrderID[] = {  {&_swigt__p_FIX__AffectedOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffectedSecondaryOrderID[] = {  {&_swigt__p_FIX__AffectedSecondaryOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffirmStatus[] = {  {&_swigt__p_FIX__AffirmStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AggregatedBook[] = {  {&_swigt__p_FIX__AggregatedBook, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AggressorIndicator[] = {  {&_swigt__p_FIX__AggressorIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementCurrency[] = {  {&_swigt__p_FIX__AgreementCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementDate[] = {  {&_swigt__p_FIX__AgreementDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementDesc[] = {  {&_swigt__p_FIX__AgreementDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementID[] = {  {&_swigt__p_FIX__AgreementID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccount[] = {  {&_swigt__p_FIX__AllocAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccountType[] = {  {&_swigt__p_FIX__AllocAccountType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccruedInterestAmt[] = {  {&_swigt__p_FIX__AllocAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAcctIDSource[] = {  {&_swigt__p_FIX__AllocAcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAvgPx[] = {  {&_swigt__p_FIX__AllocAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocCancReplaceReason[] = {  {&_swigt__p_FIX__AllocCancReplaceReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocClearingFeeIndicator[] = {  {&_swigt__p_FIX__AllocClearingFeeIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocCustomerCapacity[] = {  {&_swigt__p_FIX__AllocCustomerCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocHandlInst[] = {  {&_swigt__p_FIX__AllocHandlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocID[] = {  {&_swigt__p_FIX__AllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocInterestAtMaturity[] = {  {&_swigt__p_FIX__AllocInterestAtMaturity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocIntermedReqType[] = {  {&_swigt__p_FIX__AllocIntermedReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocLinkID[] = {  {&_swigt__p_FIX__AllocLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocLinkType[] = {  {&_swigt__p_FIX__AllocLinkType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocMethod[] = {  {&_swigt__p_FIX__AllocMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocNetMoney[] = {  {&_swigt__p_FIX__AllocNetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocNoOrdersType[] = {  {&_swigt__p_FIX__AllocNoOrdersType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocPositionEffect[] = {  {&_swigt__p_FIX__AllocPositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocPrice[] = {  {&_swigt__p_FIX__AllocPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocQty[] = {  {&_swigt__p_FIX__AllocQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocRejCode[] = {  {&_swigt__p_FIX__AllocRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportID[] = {  {&_swigt__p_FIX__AllocReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportRefID[] = {  {&_swigt__p_FIX__AllocReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportType[] = {  {&_swigt__p_FIX__AllocReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlCurrAmt[] = {  {&_swigt__p_FIX__AllocSettlCurrAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlCurrency[] = {  {&_swigt__p_FIX__AllocSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlInstType[] = {  {&_swigt__p_FIX__AllocSettlInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocShares[] = {  {&_swigt__p_FIX__AllocShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocStatus[] = {  {&_swigt__p_FIX__AllocStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocText[] = {  {&_swigt__p_FIX__AllocText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocTransType[] = {  {&_swigt__p_FIX__AllocTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocType[] = {  {&_swigt__p_FIX__AllocType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessCurr[] = {  {&_swigt__p_FIX__AllowableOneSidednessCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessPct[] = {  {&_swigt__p_FIX__AllowableOneSidednessPct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessValue[] = {  {&_swigt__p_FIX__AllowableOneSidednessValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AltMDSourceID[] = {  {&_swigt__p_FIX__AltMDSourceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplBegSeqNum[] = {  {&_swigt__p_FIX__ApplBegSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplEndSeqNum[] = {  {&_swigt__p_FIX__ApplEndSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplExtID[] = {  {&_swigt__p_FIX__ApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplID[] = {  {&_swigt__p_FIX__ApplID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplLastSeqNum[] = {  {&_swigt__p_FIX__ApplLastSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplNewSeqNum[] = {  {&_swigt__p_FIX__ApplNewSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueAction[] = {  {&_swigt__p_FIX__ApplQueueAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueDepth[] = {  {&_swigt__p_FIX__ApplQueueDepth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueMax[] = {  {&_swigt__p_FIX__ApplQueueMax, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueResolution[] = {  {&_swigt__p_FIX__ApplQueueResolution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReportID[] = {  {&_swigt__p_FIX__ApplReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReportType[] = {  {&_swigt__p_FIX__ApplReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReqID[] = {  {&_swigt__p_FIX__ApplReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReqType[] = {  {&_swigt__p_FIX__ApplReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResendFlag[] = {  {&_swigt__p_FIX__ApplResendFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseError[] = {  {&_swigt__p_FIX__ApplResponseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseID[] = {  {&_swigt__p_FIX__ApplResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseType[] = {  {&_swigt__p_FIX__ApplResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplSeqNum[] = {  {&_swigt__p_FIX__ApplSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplTotalMessageCount[] = {  {&_swigt__p_FIX__ApplTotalMessageCount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplVerID[] = {  {&_swigt__p_FIX__ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Application[] = {  {&_swigt__p_FIX__Application, 0, 0, 0},  {&_swigt__p_FIX__SynchronizedApplication, _p_FIX__SynchronizedApplicationTo_p_FIX__Application, 0, 0},  {&_swigt__p_FIX__NullApplication, _p_FIX__NullApplicationTo_p_FIX__Application, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsOfIndicator[] = {  {&_swigt__p_FIX__AsOfIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsgnRptID[] = {  {&_swigt__p_FIX__AsgnRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AssignmentMethod[] = {  {&_swigt__p_FIX__AssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AssignmentUnit[] = {  {&_swigt__p_FIX__AssignmentUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AttachmentPoint[] = {  {&_swigt__p_FIX__AttachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AutoAcceptIndicator[] = {  {&_swigt__p_FIX__AutoAcceptIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgParPx[] = {  {&_swigt__p_FIX__AvgParPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPrxPrecision[] = {  {&_swigt__p_FIX__AvgPrxPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPx[] = {  {&_swigt__p_FIX__AvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPxIndicator[] = {  {&_swigt__p_FIX__AvgPxIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPxPrecision[] = {  {&_swigt__p_FIX__AvgPxPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BOOLEAN[] = {  {&_swigt__p_FIX__BOOLEAN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisFeatureDate[] = {  {&_swigt__p_FIX__BasisFeatureDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisFeaturePrice[] = {  {&_swigt__p_FIX__BasisFeaturePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisPxType[] = {  {&_swigt__p_FIX__BasisPxType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BeginSeqNo[] = {  {&_swigt__p_FIX__BeginSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BeginString[] = {  {&_swigt__p_FIX__BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Benchmark[] = {  {&_swigt__p_FIX__Benchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurveCurrency[] = {  {&_swigt__p_FIX__BenchmarkCurveCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurveName[] = {  {&_swigt__p_FIX__BenchmarkCurveName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurvePoint[] = {  {&_swigt__p_FIX__BenchmarkCurvePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkPrice[] = {  {&_swigt__p_FIX__BenchmarkPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkPriceType[] = {  {&_swigt__p_FIX__BenchmarkPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkSecurityID[] = {  {&_swigt__p_FIX__BenchmarkSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkSecurityIDSource[] = {  {&_swigt__p_FIX__BenchmarkSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidDescriptor[] = {  {&_swigt__p_FIX__BidDescriptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidDescriptorType[] = {  {&_swigt__p_FIX__BidDescriptorType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidForwardPoints[] = {  {&_swigt__p_FIX__BidForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidForwardPoints2[] = {  {&_swigt__p_FIX__BidForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidID[] = {  {&_swigt__p_FIX__BidID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidPx[] = {  {&_swigt__p_FIX__BidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidRequestTransType[] = {  {&_swigt__p_FIX__BidRequestTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSize[] = {  {&_swigt__p_FIX__BidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSpotRate[] = {  {&_swigt__p_FIX__BidSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSwapPoints[] = {  {&_swigt__p_FIX__BidSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidTradeType[] = {  {&_swigt__p_FIX__BidTradeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidType[] = {  {&_swigt__p_FIX__BidType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidYield[] = {  {&_swigt__p_FIX__BidYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BodyLength[] = {  {&_swigt__p_FIX__BodyLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingRefID[] = {  {&_swigt__p_FIX__BookingRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingType[] = {  {&_swigt__p_FIX__BookingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingUnit[] = {  {&_swigt__p_FIX__BookingUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BoolField[] = {  {&_swigt__p_FIX__InViewOfCommon, _p_FIX__InViewOfCommonTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PrivateQuote, _p_FIX__PrivateQuoteTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ResetSeqNumFlag, _p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AggregatedBook, _p_FIX__AggregatedBookTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LegalConfirm, _p_FIX__LegalConfirmTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ForexReq, _p_FIX__ForexReqTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PublishTrdIndicator, _p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TrdRepIndicator, _p_FIX__TrdRepIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DefaultVerIndicator, _p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__RefreshIndicator, _p_FIX__RefreshIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AutoAcceptIndicator, _p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__UnsolicitedIndicator, _p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__CopyMsgIndicator, _p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, _p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TestMessageIndicator, _p_FIX__TestMessageIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__WorkingIndicator, _p_FIX__WorkingIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AggressorIndicator, _p_FIX__AggressorIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexProductEligibilityIndicator, _p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReversalIndicator, _p_FIX__ReversalIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ContraryInstructionIndicator, _p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ManualOrderIndicator, _p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReportToExch, _p_FIX__ReportToExchTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__OddLot, _p_FIX__OddLotTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__IOINaturalFlag, _p_FIX__IOINaturalFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ExchangeForPhysical, _p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LastRptRequested, _p_FIX__LastRptRequestedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__SolicitedFlag, _p_FIX__SolicitedFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TradedFlatSwitch, _p_FIX__TradedFlatSwitchTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__CustDirectedOrder, _p_FIX__CustDirectedOrderTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__BoolField, 0, 0, 0},  {&_swigt__p_FIX__LocateReqd, _p_FIX__LocateReqdTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__NotifyBrokerOfCredit, _p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__MDImplicitDelete, _p_FIX__MDImplicitDeleteTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PossDupFlag, _p_FIX__PossDupFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PreTradeAnonymity, _p_FIX__PreTradeAnonymityTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReportedPxDiff, _p_FIX__ReportedPxDiffTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ApplResendFlag, _p_FIX__ApplResendFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PreviouslyReported, _p_FIX__PreviouslyReportedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LastFragment, _p_FIX__LastFragmentTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__GapFillFlag, _p_FIX__GapFillFlagTo_p_FIX__BoolField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BrokerOfCredit[] = {  {&_swigt__p_FIX__BrokerOfCredit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BusinessRejectReason[] = {  {&_swigt__p_FIX__BusinessRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BusinessRejectRefID[] = {  {&_swigt__p_FIX__BusinessRejectRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BuyVolume[] = {  {&_swigt__p_FIX__BuyVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CFICode[] = {  {&_swigt__p_FIX__CFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CHAR[] = {  {&_swigt__p_FIX__CHAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__COUNTRY[] = {  {&_swigt__p_FIX__COUNTRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CPProgram[] = {  {&_swigt__p_FIX__CPProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CPRegType[] = {  {&_swigt__p_FIX__CPRegType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CURRENCY[] = {  {&_swigt__p_FIX__CURRENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CalculatedCcyLastQty[] = {  {&_swigt__p_FIX__CalculatedCcyLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CancellationRights[] = {  {&_swigt__p_FIX__CancellationRights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CapPrice[] = {  {&_swigt__p_FIX__CapPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardExpDate[] = {  {&_swigt__p_FIX__CardExpDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardHolderName[] = {  {&_swigt__p_FIX__CardHolderName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardIssNo[] = {  {&_swigt__p_FIX__CardIssNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardIssNum[] = {  {&_swigt__p_FIX__CardIssNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardNumber[] = {  {&_swigt__p_FIX__CardNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardStartDate[] = {  {&_swigt__p_FIX__CardStartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentAcctName[] = {  {&_swigt__p_FIX__CashDistribAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentAcctNumber[] = {  {&_swigt__p_FIX__CashDistribAgentAcctNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentCode[] = {  {&_swigt__p_FIX__CashDistribAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentName[] = {  {&_swigt__p_FIX__CashDistribAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribCurr[] = {  {&_swigt__p_FIX__CashDistribCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribPayRef[] = {  {&_swigt__p_FIX__CashDistribPayRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashMargin[] = {  {&_swigt__p_FIX__CashMargin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashOrderQty[] = {  {&_swigt__p_FIX__CashOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashOutstanding[] = {  {&_swigt__p_FIX__CashOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentAcctName[] = {  {&_swigt__p_FIX__CashSettlAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentAcctNum[] = {  {&_swigt__p_FIX__CashSettlAgentAcctNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentCode[] = {  {&_swigt__p_FIX__CashSettlAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentContactName[] = {  {&_swigt__p_FIX__CashSettlAgentContactName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentContactPhone[] = {  {&_swigt__p_FIX__CashSettlAgentContactPhone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentName[] = {  {&_swigt__p_FIX__CashSettlAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CcyAmt[] = {  {&_swigt__p_FIX__CcyAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CharField[] = {  {&_swigt__p_FIX__MDEntryType, _p_FIX__MDEntryTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistStatus, _p_FIX__RegistStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrdStatus, _p_FIX__OrdStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MatchStatus, _p_FIX__MatchStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__FundRenewWaiv, _p_FIX__FundRenewWaivTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OpenClose, _p_FIX__OpenCloseTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Urgency, _p_FIX__UrgencyTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIOthSvc, _p_FIX__IOIOthSvcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__EmailType, _p_FIX__EmailTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlObligTransType, _p_FIX__SettlObligTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ListExecInstType, _p_FIX__ListExecInstTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DlvyInstType, _p_FIX__DlvyInstTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecType, _p_FIX__ExecTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstMode, _p_FIX__SettlInstModeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CharField, 0, 0, 0},  {&_swigt__p_FIX__TimeInForce, _p_FIX__TimeInForceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerType, _p_FIX__TriggerTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OwnershipType, _p_FIX__OwnershipTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AssignmentMethod, _p_FIX__AssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlMethod, _p_FIX__SettlMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, _p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__InstrmtAssignmentMethod, _p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeSettlMethod, _p_FIX__DerivativeSettlMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MDReqRejReason, _p_FIX__MDReqRejReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BookingUnit, _p_FIX__BookingUnitTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRateCalc, _p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRateCalc, _p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerAction, _p_FIX__TriggerActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DiscretionInst, _p_FIX__DiscretionInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecInstValue, _p_FIX__ExecInstValueTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlObligSource, _p_FIX__SettlObligSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MassCancelRequestType, _p_FIX__MassCancelRequestTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SubscriptionRequestType, _p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceTypeScope, _p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ProcessCode, _p_FIX__ProcessCodeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LotType, _p_FIX__LotTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSide, _p_FIX__LegSideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__HaltReasonChar, _p_FIX__HaltReasonCharTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrderCapacity, _p_FIX__OrderCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DealingCapacity, _p_FIX__DealingCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LastCapacity, _p_FIX__LastCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PriceProtectionScope, _p_FIX__PriceProtectionScopeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BasisPxType, _p_FIX__BasisPxTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PositionEffect, _p_FIX__PositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegPositionEffect, _p_FIX__LegPositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AllocPositionEffect, _p_FIX__AllocPositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__VenueType, _p_FIX__VenueTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__HandlInst, _p_FIX__HandlInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MoneyLaunderingStatus, _p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecAckStatus, _p_FIX__ExecAckStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CxlRejResponseTo, _p_FIX__CxlRejResponseToTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DisplayWhen, _p_FIX__DisplayWhenTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrderCategory, _p_FIX__OrderCategoryTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MultiLegReportingType, _p_FIX__MultiLegReportingTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CxlType, _p_FIX__CxlTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Side, _p_FIX__SideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested4PartyIDSource, _p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExDestinationIDSource, _p_FIX__ExDestinationIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested3PartyIDSource, _p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TargetPartyIDSource, _p_FIX__TargetPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyIDSource, _p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstSource, _p_FIX__SettlInstSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__NestedPartyIDSource, _p_FIX__NestedPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CommType, _p_FIX__CommTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PartyIDSource, _p_FIX__PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RefOrderIDSource, _p_FIX__RefOrderIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested2PartyIDSource, _p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MassCancelResponse, _p_FIX__MassCancelResponseTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerOrderType, _p_FIX__TriggerOrderTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSettlType, _p_FIX__LegSettlTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSettlmntTyp, _p_FIX__LegSettlmntTypTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlmntTyp, _p_FIX__SettlmntTypTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PreallocMethod, _p_FIX__PreallocMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExerciseMethod, _p_FIX__ExerciseMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AsOfIndicator, _p_FIX__AsOfIndicatorTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DisplayMethod, _p_FIX__DisplayMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrigTradeHandlingInstr, _p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradeHandlingInstr, _p_FIX__TradeHandlingInstrTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DeleteReason, _p_FIX__DeleteReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DKReason, _p_FIX__DKReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CancellationRights, _p_FIX__CancellationRightsTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CashMargin, _p_FIX__CashMarginTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Rule80A, _p_FIX__Rule80ATo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DayBookingInst, _p_FIX__DayBookingInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AdvSide, _p_FIX__AdvSideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegOptAttribute, _p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OptAttribute, _p_FIX__OptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingOptAttribute, _p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIQltyInd, _p_FIX__IOIQltyIndTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegOptAttribute, _p_FIX__LegOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradSesUpdateAction, _p_FIX__TradSesUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SecurityUpdateAction, _p_FIX__SecurityUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ListUpdateAction, _p_FIX__ListUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrdType, _p_FIX__OrdTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MarketUpdateAction, _p_FIX__MarketUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MDUpdateAction, _p_FIX__MDUpdateActionTo_p_FIX__CharField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSum[] = {  {&_swigt__p_FIX__CheckSum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSumField[] = {  {&_swigt__p_FIX__CheckSumField, 0, 0, 0},  {&_swigt__p_FIX__CheckSum, _p_FIX__CheckSumTo_p_FIX__CheckSumField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClOrdID[] = {  {&_swigt__p_FIX__ClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClOrdLinkID[] = {  {&_swigt__p_FIX__ClOrdLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingAccount[] = {  {&_swigt__p_FIX__ClearingAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingBusinessDate[] = {  {&_swigt__p_FIX__ClearingBusinessDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingFeeIndicator[] = {  {&_swigt__p_FIX__ClearingFeeIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingFirm[] = {  {&_swigt__p_FIX__ClearingFirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingInstruction[] = {  {&_swigt__p_FIX__ClearingInstruction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClientBidID[] = {  {&_swigt__p_FIX__ClientBidID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClientID[] = {  {&_swigt__p_FIX__ClientID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAction[] = {  {&_swigt__p_FIX__CollAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollApplType[] = {  {&_swigt__p_FIX__CollApplType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnID[] = {  {&_swigt__p_FIX__CollAsgnID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnReason[] = {  {&_swigt__p_FIX__CollAsgnReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRefID[] = {  {&_swigt__p_FIX__CollAsgnRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRejectReason[] = {  {&_swigt__p_FIX__CollAsgnRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRespType[] = {  {&_swigt__p_FIX__CollAsgnRespType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnTransType[] = {  {&_swigt__p_FIX__CollAsgnTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryID[] = {  {&_swigt__p_FIX__CollInquiryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryQualifier[] = {  {&_swigt__p_FIX__CollInquiryQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryResult[] = {  {&_swigt__p_FIX__CollInquiryResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryStatus[] = {  {&_swigt__p_FIX__CollInquiryStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollReqID[] = {  {&_swigt__p_FIX__CollReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollRespID[] = {  {&_swigt__p_FIX__CollRespID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollRptID[] = {  {&_swigt__p_FIX__CollRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollStatus[] = {  {&_swigt__p_FIX__CollStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CommCurrency[] = {  {&_swigt__p_FIX__CommCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CommType[] = {  {&_swigt__p_FIX__CommType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Commission[] = {  {&_swigt__p_FIX__Commission, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventCondition[] = {  {&_swigt__p_FIX__ComplexEventCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventEndDate[] = {  {&_swigt__p_FIX__ComplexEventEndDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventEndTime[] = {  {&_swigt__p_FIX__ComplexEventEndTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPrice[] = {  {&_swigt__p_FIX__ComplexEventPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceBoundaryMethod[] = {  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceBoundaryPrecision[] = {  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceTimeType[] = {  {&_swigt__p_FIX__ComplexEventPriceTimeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventStartDate[] = {  {&_swigt__p_FIX__ComplexEventStartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventStartTime[] = {  {&_swigt__p_FIX__ComplexEventStartTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventType[] = {  {&_swigt__p_FIX__ComplexEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexOptPayoutAmount[] = {  {&_swigt__p_FIX__ComplexOptPayoutAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplianceID[] = {  {&_swigt__p_FIX__ComplianceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Concession[] = {  {&_swigt__p_FIX__Concession, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfigError[] = {  {&_swigt__p_FIX__ConfigError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmID[] = {  {&_swigt__p_FIX__ConfirmID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmRefID[] = {  {&_swigt__p_FIX__ConfirmRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmRejReason[] = {  {&_swigt__p_FIX__ConfirmRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmReqID[] = {  {&_swigt__p_FIX__ConfirmReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmStatus[] = {  {&_swigt__p_FIX__ConfirmStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmTransType[] = {  {&_swigt__p_FIX__ConfirmTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmType[] = {  {&_swigt__p_FIX__ConfirmType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtCurr[] = {  {&_swigt__p_FIX__ContAmtCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtType[] = {  {&_swigt__p_FIX__ContAmtType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtValue[] = {  {&_swigt__p_FIX__ContAmtValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContIntRptID[] = {  {&_swigt__p_FIX__ContIntRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContingencyType[] = {  {&_swigt__p_FIX__ContingencyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraBroker[] = {  {&_swigt__p_FIX__ContraBroker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraLegRefID[] = {  {&_swigt__p_FIX__ContraLegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTradeQty[] = {  {&_swigt__p_FIX__ContraTradeQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTradeTime[] = {  {&_swigt__p_FIX__ContraTradeTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTrader[] = {  {&_swigt__p_FIX__ContraTrader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractMultiplier[] = {  {&_swigt__p_FIX__ContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractMultiplierUnit[] = {  {&_swigt__p_FIX__ContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractSettlMonth[] = {  {&_swigt__p_FIX__ContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraryInstructionIndicator[] = {  {&_swigt__p_FIX__ContraryInstructionIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CopyMsgIndicator[] = {  {&_swigt__p_FIX__CopyMsgIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CorporateAction[] = {  {&_swigt__p_FIX__CorporateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Country[] = {  {&_swigt__p_FIX__Country, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CountryOfIssue[] = {  {&_swigt__p_FIX__CountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CouponPaymentDate[] = {  {&_swigt__p_FIX__CouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CouponRate[] = {  {&_swigt__p_FIX__CouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CoveredOrUncovered[] = {  {&_swigt__p_FIX__CoveredOrUncovered, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CreditRating[] = {  {&_swigt__p_FIX__CreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossID[] = {  {&_swigt__p_FIX__CrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossPercent[] = {  {&_swigt__p_FIX__CrossPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossPrioritization[] = {  {&_swigt__p_FIX__CrossPrioritization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossType[] = {  {&_swigt__p_FIX__CrossType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CstmApplVerID[] = {  {&_swigt__p_FIX__CstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CumQty[] = {  {&_swigt__p_FIX__CumQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Currency[] = {  {&_swigt__p_FIX__Currency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CurrencyRatio[] = {  {&_swigt__p_FIX__CurrencyRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustDirectedOrder[] = {  {&_swigt__p_FIX__CustDirectedOrder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustOrderCapacity[] = {  {&_swigt__p_FIX__CustOrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustOrderHandlingInst[] = {  {&_swigt__p_FIX__CustOrderHandlingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustomerOrFirm[] = {  {&_swigt__p_FIX__CustomerOrFirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlQty[] = {  {&_swigt__p_FIX__CxlQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlRejReason[] = {  {&_swigt__p_FIX__CxlRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlRejResponseTo[] = {  {&_swigt__p_FIX__CxlRejResponseTo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlType[] = {  {&_swigt__p_FIX__CxlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DATA[] = {  {&_swigt__p_FIX__DATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DAYOFMONTH[] = {  {&_swigt__p_FIX__DAYOFMONTH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DKReason[] = {  {&_swigt__p_FIX__DKReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DataDictionary[] = {  {&_swigt__p_FIX__DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DataDictionaryNotFound[] = {  {&_swigt__p_FIX__DataDictionaryNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DateOfBirth[] = {  {&_swigt__p_FIX__DateOfBirth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DatedDate[] = {  {&_swigt__p_FIX__DatedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayAvgPx[] = {  {&_swigt__p_FIX__DayAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayBookingInst[] = {  {&_swigt__p_FIX__DayBookingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayCumQty[] = {  {&_swigt__p_FIX__DayCumQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayOrderQty[] = {  {&_swigt__p_FIX__DayOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DealingCapacity[] = {  {&_swigt__p_FIX__DealingCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefBidSize[] = {  {&_swigt__p_FIX__DefBidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefOfferSize[] = {  {&_swigt__p_FIX__DefOfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultApplExtID[] = {  {&_swigt__p_FIX__DefaultApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultApplVerID[] = {  {&_swigt__p_FIX__DefaultApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultCstmApplVerID[] = {  {&_swigt__p_FIX__DefaultCstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultVerIndicator[] = {  {&_swigt__p_FIX__DefaultVerIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeleteReason[] = {  {&_swigt__p_FIX__DeleteReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToCompID[] = {  {&_swigt__p_FIX__DeliverToCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToLocationID[] = {  {&_swigt__p_FIX__DeliverToLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToSubID[] = {  {&_swigt__p_FIX__DeliverToSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryDate[] = {  {&_swigt__p_FIX__DeliveryDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryForm[] = {  {&_swigt__p_FIX__DeliveryForm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryType[] = {  {&_swigt__p_FIX__DeliveryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivFlexProductEligibilityIndicator[] = {  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCFICode[] = {  {&_swigt__p_FIX__DerivativeCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCapPrice[] = {  {&_swigt__p_FIX__DerivativeCapPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractMultiplier[] = {  {&_swigt__p_FIX__DerivativeContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractMultiplierUnit[] = {  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractSettlMonth[] = {  {&_swigt__p_FIX__DerivativeContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCountryOfIssue[] = {  {&_swigt__p_FIX__DerivativeCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedIssuer[] = {  {&_swigt__p_FIX__DerivativeEncodedIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedIssuerLen[] = {  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedSecurityDesc[] = {  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventDate[] = {  {&_swigt__p_FIX__DerivativeEventDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventPx[] = {  {&_swigt__p_FIX__DerivativeEventPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventText[] = {  {&_swigt__p_FIX__DerivativeEventText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventTime[] = {  {&_swigt__p_FIX__DerivativeEventTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventType[] = {  {&_swigt__p_FIX__DerivativeEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeExerciseStyle[] = {  {&_swigt__p_FIX__DerivativeExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFloorPrice[] = {  {&_swigt__p_FIX__DerivativeFloorPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFlowScheduleType[] = {  {&_swigt__p_FIX__DerivativeFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFuturesValuationMethod[] = {  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrAttribType[] = {  {&_swigt__p_FIX__DerivativeInstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrAttribValue[] = {  {&_swigt__p_FIX__DerivativeInstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrRegistry[] = {  {&_swigt__p_FIX__DerivativeInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrmtAssignmentMethod[] = {  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyID[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyRole[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartySubID[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeIssueDate[] = {  {&_swigt__p_FIX__DerivativeIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeIssuer[] = {  {&_swigt__p_FIX__DerivativeIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeListMethod[] = {  {&_swigt__p_FIX__DerivativeListMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeLocaleOfIssue[] = {  {&_swigt__p_FIX__DerivativeLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityDate[] = {  {&_swigt__p_FIX__DerivativeMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityMonthYear[] = {  {&_swigt__p_FIX__DerivativeMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityTime[] = {  {&_swigt__p_FIX__DerivativeMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMinPriceIncrement[] = {  {&_swigt__p_FIX__DerivativeMinPriceIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMinPriceIncrementAmount[] = {  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeNTPositionLimit[] = {  {&_swigt__p_FIX__DerivativeNTPositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeOptAttribute[] = {  {&_swigt__p_FIX__DerivativeOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeOptPayAmount[] = {  {&_swigt__p_FIX__DerivativeOptPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePositionLimit[] = {  {&_swigt__p_FIX__DerivativePositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceQuoteMethod[] = {  {&_swigt__p_FIX__DerivativePriceQuoteMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceUnitOfMeasure[] = {  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeProduct[] = {  {&_swigt__p_FIX__DerivativeProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeProductComplex[] = {  {&_swigt__p_FIX__DerivativeProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePutOrCall[] = {  {&_swigt__p_FIX__DerivativePutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityAltID[] = {  {&_swigt__p_FIX__DerivativeSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityAltIDSource[] = {  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityDesc[] = {  {&_swigt__p_FIX__DerivativeSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityExchange[] = {  {&_swigt__p_FIX__DerivativeSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityGroup[] = {  {&_swigt__p_FIX__DerivativeSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityID[] = {  {&_swigt__p_FIX__DerivativeSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityIDSource[] = {  {&_swigt__p_FIX__DerivativeSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityStatus[] = {  {&_swigt__p_FIX__DerivativeSecurityStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecuritySubType[] = {  {&_swigt__p_FIX__DerivativeSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityType[] = {  {&_swigt__p_FIX__DerivativeSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXML[] = {  {&_swigt__p_FIX__DerivativeSecurityXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXMLLen[] = {  {&_swigt__p_FIX__DerivativeSecurityXMLLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXMLSchema[] = {  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSettlMethod[] = {  {&_swigt__p_FIX__DerivativeSettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSettleOnOpenFlag[] = {  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeCurrency[] = {  {&_swigt__p_FIX__DerivativeStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeMultiplier[] = {  {&_swigt__p_FIX__DerivativeStrikeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikePrice[] = {  {&_swigt__p_FIX__DerivativeStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeValue[] = {  {&_swigt__p_FIX__DerivativeStrikeValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSymbol[] = {  {&_swigt__p_FIX__DerivativeSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSymbolSfx[] = {  {&_swigt__p_FIX__DerivativeSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeTimeUnit[] = {  {&_swigt__p_FIX__DerivativeTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeUnitOfMeasure[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeUnitOfMeasureQty[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeValuationMethod[] = {  {&_swigt__p_FIX__DerivativeValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Designation[] = {  {&_swigt__p_FIX__Designation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskID[] = {  {&_swigt__p_FIX__DeskID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskOrderHandlingInst[] = {  {&_swigt__p_FIX__DeskOrderHandlingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskType[] = {  {&_swigt__p_FIX__DeskType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskTypeSource[] = {  {&_swigt__p_FIX__DeskTypeSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DetachmentPoint[] = {  {&_swigt__p_FIX__DetachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Dictionary[] = {  {&_swigt__p_FIX__Dictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Dictionary__Data__const_iterator[] = {  {&_swigt__p_FIX__Dictionary__Data__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionInst[] = {  {&_swigt__p_FIX__DiscretionInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionLimitType[] = {  {&_swigt__p_FIX__DiscretionLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionMoveType[] = {  {&_swigt__p_FIX__DiscretionMoveType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffset[] = {  {&_swigt__p_FIX__DiscretionOffset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffsetType[] = {  {&_swigt__p_FIX__DiscretionOffsetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffsetValue[] = {  {&_swigt__p_FIX__DiscretionOffsetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionPrice[] = {  {&_swigt__p_FIX__DiscretionPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionRoundDirection[] = {  {&_swigt__p_FIX__DiscretionRoundDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionScope[] = {  {&_swigt__p_FIX__DiscretionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayHighQty[] = {  {&_swigt__p_FIX__DisplayHighQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayLowQty[] = {  {&_swigt__p_FIX__DisplayLowQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayMethod[] = {  {&_swigt__p_FIX__DisplayMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayMinIncr[] = {  {&_swigt__p_FIX__DisplayMinIncr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayQty[] = {  {&_swigt__p_FIX__DisplayQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayWhen[] = {  {&_swigt__p_FIX__DisplayWhen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DistribPaymentMethod[] = {  {&_swigt__p_FIX__DistribPaymentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DistribPercentage[] = {  {&_swigt__p_FIX__DistribPercentage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DividendYield[] = {  {&_swigt__p_FIX__DividendYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DlvyInst[] = {  {&_swigt__p_FIX__DlvyInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DlvyInstType[] = {  {&_swigt__p_FIX__DlvyInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoNotSend[] = {  {&_swigt__p_FIX__DoNotSend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoubleField[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, _p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, _p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasureQty, _p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLastPx, _p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastPx, _p_FIX__LegLastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastPx, _p_FIX__LastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ReportedPx, _p_FIX__ReportedPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MidPx, _p_FIX__MidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayLowQty, _p_FIX__DisplayLowQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RoundingModulus, _p_FIX__RoundingModulusTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegRatioQty, _p_FIX__LegRatioQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RatioQty, _p_FIX__RatioQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntrySize, _p_FIX__MDEntrySizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexEventPrice, _p_FIX__ComplexEventPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LeavesQty, _p_FIX__LeavesQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Quantity, _p_FIX__QuantityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, _p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalTakedown, _p_FIX__TotalTakedownTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayMinIncr, _p_FIX__DisplayMinIncrTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Factor, _p_FIX__FactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingFactor, _p_FIX__UnderlyingFactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegFactor, _p_FIX__LegFactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AccruedInterestAmt, _p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalAccruedInterestAmt, _p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocAccruedInterestAmt, _p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndAccruedInterestAmt, _p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RndPx, _p_FIX__RndPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ThresholdAmount, _p_FIX__ThresholdAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexOptPayoutAmount, _p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCollectAmount, _p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OptPayoutAmount, _p_FIX__OptPayoutAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDirtyPrice, _p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AvgParPx, _p_FIX__AvgParPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ShortQty, _p_FIX__ShortQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocAvgPx, _p_FIX__AllocAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerNewPrice, _p_FIX__TriggerNewPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PeggedRefPrice, _p_FIX__PeggedRefPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContraTradeQty, _p_FIX__ContraTradeQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderBookingQty, _p_FIX__OrderBookingQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingQty, _p_FIX__UnderlyingQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Commission, _p_FIX__CommissionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SharedCommission, _p_FIX__SharedCommissionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayAvgPx, _p_FIX__DayAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RepurchaseRate, _p_FIX__RepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseRate, _p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegRepurchaseRate, _p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AttachmentPoint, _p_FIX__AttachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAttachmentPoint, _p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DetachmentPoint, _p_FIX__DetachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDetachmentPoint, _p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOptionRatio, _p_FIX__LegOptionRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MarginRatio, _p_FIX__MarginRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingEndValue, _p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidPx, _p_FIX__BidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessValue, _p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TimeToExpiration, _p_FIX__TimeToExpirationTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints, _p_FIX__OfferForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntryForwardPoints, _p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidForwardPoints, _p_FIX__BidForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSwapPoints, _p_FIX__OfferSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSwapPoints, _p_FIX__BidSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOfferForwardPoints, _p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastForwardPoints, _p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SwapPoints, _p_FIX__SwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastForwardPoints, _p_FIX__LastForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBidForwardPoints, _p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastSwapPoints, _p_FIX__LastSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StopPx, _p_FIX__StopPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRate, _p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NetChgPrevDay, _p_FIX__NetChgPrevDayTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDeliveryAmount, _p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeOptPayAmount, _p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OptPayAmount, _p_FIX__OptPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CapPrice, _p_FIX__CapPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeCapPrice, _p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferPx, _p_FIX__OfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferYield, _p_FIX__OfferYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Price, _p_FIX__PriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PegDifference, _p_FIX__PegDifferenceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinQty, _p_FIX__MinQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MiscFeeAmt, _p_FIX__MiscFeeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastParPx, _p_FIX__LastParPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceImprovement, _p_FIX__PriceImprovementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessPct, _p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OutsideIndexPct, _p_FIX__OutsideIndexPctTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SellVolume, _p_FIX__SellVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PeggedPrice, _p_FIX__PeggedPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PrevClosePx, _p_FIX__PrevClosePxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndStrikePxRange, _p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartStrikePxRange, _p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCalculatedCcyLastQty, _p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastQty, _p_FIX__LegLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastForwardPoints2, _p_FIX__LastForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints2, _p_FIX__OfferForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidForwardPoints2, _p_FIX__BidForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPx, _p_FIX__UnderlyingPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryDisplayQty, _p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayQty, _p_FIX__DisplayQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderQty2, _p_FIX__OrderQty2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionOffset, _p_FIX__DiscretionOffsetTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityPctLow, _p_FIX__LiquidityPctLowTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocQty, _p_FIX__AllocQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegAllocQty, _p_FIX__LegAllocQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighPx, _p_FIX__HighPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DoubleField, 0, 0, 0},  {&_swigt__p_FIX__FirstPx, _p_FIX__FirstPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TargetStrategyPerformance, _p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CashOutstanding, _p_FIX__CashOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, _p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NotionalPercentageOutstanding, _p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, _p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionPrice, _p_FIX__DiscretionPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPrice, _p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrAmt, _p_FIX__SettlCurrAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrAmt, _p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Yield, _p_FIX__YieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingEndPrice, _p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeValue, _p_FIX__StrikeValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeValue, _p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayHighQty, _p_FIX__DisplayHighQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AvgPx, _p_FIX__AvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRate, _p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrOfferFxRate, _p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrBidFxRate, _p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, _p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MidYield, _p_FIX__MidYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidYield, _p_FIX__BidYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinTradeVol, _p_FIX__MinTradeVolTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxTradeVol, _p_FIX__MaxTradeVolTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FillQty, _p_FIX__FillQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Spread, _p_FIX__SpreadTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndCash, _p_FIX__EndCashTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Concession, _p_FIX__ConcessionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponRate, _p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastShares, _p_FIX__LastSharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CouponRate, _p_FIX__CouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCouponRate, _p_FIX__LegCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegPrice, _p_FIX__LegPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AssignmentUnit, _p_FIX__AssignmentUnitTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OutMainCntryUIndex, _p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxShow, _p_FIX__MaxShowTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LowPx, _p_FIX__LowPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RoundLot, _p_FIX__RoundLotTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskFreeRate, _p_FIX__RiskFreeRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderCapacityQty, _p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PctAtRisk, _p_FIX__PctAtRiskTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RefreshQty, _p_FIX__RefreshQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PosAmt, _p_FIX__PosAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MarginExcess, _p_FIX__MarginExcessTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PegOffsetValue, _p_FIX__PegOffsetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContAmtValue, _p_FIX__ContAmtValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetValue, _p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalNetValue, _p_FIX__TotalNetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DividendYield, _p_FIX__DividendYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegDividendYield, _p_FIX__LegDividendYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntryPx, _p_FIX__MDEntryPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxFloor, _p_FIX__MaxFloorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocInterestAtMaturity, _p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__InterestAtMaturity, _p_FIX__InterestAtMaturityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxPriceVariation, _p_FIX__MaxPriceVariationTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CcyAmt, _p_FIX__CcyAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Shares, _p_FIX__SharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocShares, _p_FIX__AllocSharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EventPx, _p_FIX__EventPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeEventPx, _p_FIX__DerivativeEventPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceDelta, _p_FIX__PriceDeltaTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegVolatility, _p_FIX__LegVolatilityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Volatility, _p_FIX__VolatilityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegQty, _p_FIX__LegQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinBidSize, _p_FIX__MinBidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DefBidSize, _p_FIX__DefBidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSize, _p_FIX__BidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegStrikePrice, _p_FIX__LegStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikePrice, _p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryTradingReferencePrice, _p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradingReferencePrice, _p_FIX__TradingReferencePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikePrice, _p_FIX__StrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikePrice, _p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegStrikePrice, _p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CurrencyRatio, _p_FIX__CurrencyRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCurrencyRatio, _p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DistribPercentage, _p_FIX__DistribPercentageTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ExpQty, _p_FIX__ExpQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOrderQty, _p_FIX__LegOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CashOrderQty, _p_FIX__CashOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayOrderQty, _p_FIX__DayOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderQty, _p_FIX__OrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocNetMoney, _p_FIX__AllocNetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NetMoney, _p_FIX__NetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaturityNetMoney, _p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LongQty, _p_FIX__LongQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingStartValue, _p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrentValue, _p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinOfferSize, _p_FIX__MinOfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSize, _p_FIX__OfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DefOfferSize, _p_FIX__DefOfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FairValue, _p_FIX__FairValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CxlQty, _p_FIX__CxlQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideValue1, _p_FIX__SideValue1To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideValue2, _p_FIX__SideValue2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MktBidPx, _p_FIX__MktBidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityValue, _p_FIX__LiquidityValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartCash, _p_FIX__StartCashTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__WtAverageLiquidity, _p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTraded, _p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FillPx, _p_FIX__FillPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BasisFeaturePrice, _p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EFPTrackingError, _p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerNewQty, _p_FIX__TriggerNewQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Price2, _p_FIX__Price2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LowLimitPrice, _p_FIX__LowLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinLotSize, _p_FIX__MinLotSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocPrice, _p_FIX__AllocPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ValueOfFutures, _p_FIX__ValueOfFuturesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CumQty, _p_FIX__CumQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityPctHigh, _p_FIX__LiquidityPctHighTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CrossPercent, _p_FIX__CrossPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderPercent, _p_FIX__OrderPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAllocationPercent, _p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AccruedInterestRate, _p_FIX__AccruedInterestRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDSecSize, _p_FIX__MDSecSizeTo_p_FIX__DoubleField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DueToRelated[] = {  {&_swigt__p_FIX__DueToRelated, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DuplicateFieldNumber[] = {  {&_swigt__p_FIX__DuplicateFieldNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EFPTrackingError[] = {  {&_swigt__p_FIX__EFPTrackingError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EXCHANGE[] = {  {&_swigt__p_FIX__EXCHANGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EffectiveTime[] = {  {&_swigt__p_FIX__EffectiveTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EmailThreadID[] = {  {&_swigt__p_FIX__EmailThreadID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EmailType[] = {  {&_swigt__p_FIX__EmailType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedAllocText[] = {  {&_swigt__p_FIX__EncodedAllocText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedAllocTextLen[] = {  {&_swigt__p_FIX__EncodedAllocTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedHeadline[] = {  {&_swigt__p_FIX__EncodedHeadline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedHeadlineLen[] = {  {&_swigt__p_FIX__EncodedHeadlineLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedIssuer[] = {  {&_swigt__p_FIX__EncodedIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedIssuerLen[] = {  {&_swigt__p_FIX__EncodedIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegIssuer[] = {  {&_swigt__p_FIX__EncodedLegIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegIssuerLen[] = {  {&_swigt__p_FIX__EncodedLegIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegSecurityDesc[] = {  {&_swigt__p_FIX__EncodedLegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedLegSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListExecInst[] = {  {&_swigt__p_FIX__EncodedListExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListExecInstLen[] = {  {&_swigt__p_FIX__EncodedListExecInstLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListStatusText[] = {  {&_swigt__p_FIX__EncodedListStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListStatusTextLen[] = {  {&_swigt__p_FIX__EncodedListStatusTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedMktSegmDesc[] = {  {&_swigt__p_FIX__EncodedMktSegmDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedMktSegmDescLen[] = {  {&_swigt__p_FIX__EncodedMktSegmDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityDesc[] = {  {&_swigt__p_FIX__EncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityListDesc[] = {  {&_swigt__p_FIX__EncodedSecurityListDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityListDescLen[] = {  {&_swigt__p_FIX__EncodedSecurityListDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSubject[] = {  {&_swigt__p_FIX__EncodedSubject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSubjectLen[] = {  {&_swigt__p_FIX__EncodedSubjectLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedText[] = {  {&_swigt__p_FIX__EncodedText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedTextLen[] = {  {&_swigt__p_FIX__EncodedTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingIssuer[] = {  {&_swigt__p_FIX__EncodedUnderlyingIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingIssuerLen[] = {  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingSecurityDesc[] = {  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptMethod[] = {  {&_swigt__p_FIX__EncryptMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedNewPassword[] = {  {&_swigt__p_FIX__EncryptedNewPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedNewPasswordLen[] = {  {&_swigt__p_FIX__EncryptedNewPasswordLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPassword[] = {  {&_swigt__p_FIX__EncryptedPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPasswordLen[] = {  {&_swigt__p_FIX__EncryptedPasswordLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPasswordMethod[] = {  {&_swigt__p_FIX__EncryptedPasswordMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndAccruedInterestAmt[] = {  {&_swigt__p_FIX__EndAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndCash[] = {  {&_swigt__p_FIX__EndCash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndDate[] = {  {&_swigt__p_FIX__EndDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndMaturityMonthYear[] = {  {&_swigt__p_FIX__EndMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndSeqNo[] = {  {&_swigt__p_FIX__EndSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndStrikePxRange[] = {  {&_swigt__p_FIX__EndStrikePxRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndTickPriceRange[] = {  {&_swigt__p_FIX__EndTickPriceRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventDate[] = {  {&_swigt__p_FIX__EventDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventPx[] = {  {&_swigt__p_FIX__EventPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventText[] = {  {&_swigt__p_FIX__EventText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventTime[] = {  {&_swigt__p_FIX__EventTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventType[] = {  {&_swigt__p_FIX__EventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDate[] = {  {&_swigt__p_FIX__ExDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDestination[] = {  {&_swigt__p_FIX__ExDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDestinationIDSource[] = {  {&_swigt__p_FIX__ExDestinationIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Exception[] = {  {&_swigt__p_FIX__RequiredTagMissing, _p_FIX__RequiredTagMissingTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidTagNumber, _p_FIX__InvalidTagNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RejectLogon, _p_FIX__RejectLogonTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectDataFormat, _p_FIX__IncorrectDataFormatTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagNotDefinedForMessage, _p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessage, _p_FIX__InvalidMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DoNotSend, _p_FIX__DoNotSendTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RuntimeError, _p_FIX__RuntimeErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__MessageParseError, _p_FIX__MessageParseErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DuplicateFieldNumber, _p_FIX__DuplicateFieldNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldNotFound, _p_FIX__FieldNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DataDictionaryNotFound, _p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SessionNotFound, _p_FIX__SessionNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__Exception, 0, 0, 0},  {&_swigt__p_FIX__IOException, _p_FIX__IOExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketException, _p_FIX__SocketExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__ConfigError, _p_FIX__ConfigErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessageType, _p_FIX__InvalidMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__UnsupportedMessageType, _p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__UnsupportedVersion, _p_FIX__UnsupportedVersionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectTagValue, _p_FIX__IncorrectTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__NoTagValue, _p_FIX__NoTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagOutOfOrder, _p_FIX__TagOutOfOrderTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatedTag, _p_FIX__RepeatedTagTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldConvertError, _p_FIX__FieldConvertErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectMessageStructure, _p_FIX__IncorrectMessageStructureTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatingGroupCountMismatch, _p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeForPhysical[] = {  {&_swigt__p_FIX__ExchangeForPhysical, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeRule[] = {  {&_swigt__p_FIX__ExchangeRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeSpecialInstructions[] = {  {&_swigt__p_FIX__ExchangeSpecialInstructions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecAckStatus[] = {  {&_swigt__p_FIX__ExecAckStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecBroker[] = {  {&_swigt__p_FIX__ExecBroker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecID[] = {  {&_swigt__p_FIX__ExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecInst[] = {  {&_swigt__p_FIX__ExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecInstValue[] = {  {&_swigt__p_FIX__ExecInstValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecPriceAdjustment[] = {  {&_swigt__p_FIX__ExecPriceAdjustment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecPriceType[] = {  {&_swigt__p_FIX__ExecPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecRefID[] = {  {&_swigt__p_FIX__ExecRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecRestatementReason[] = {  {&_swigt__p_FIX__ExecRestatementReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecTransType[] = {  {&_swigt__p_FIX__ExecTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecType[] = {  {&_swigt__p_FIX__ExecType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecValuationPoint[] = {  {&_swigt__p_FIX__ExecValuationPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExerciseMethod[] = {  {&_swigt__p_FIX__ExerciseMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExerciseStyle[] = {  {&_swigt__p_FIX__ExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpQty[] = {  {&_swigt__p_FIX__ExpQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpType[] = {  {&_swigt__p_FIX__ExpType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpirationCycle[] = {  {&_swigt__p_FIX__ExpirationCycle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpirationQtyType[] = {  {&_swigt__p_FIX__ExpirationQtyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpireDate[] = {  {&_swigt__p_FIX__ExpireDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpireTime[] = {  {&_swigt__p_FIX__ExpireTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FLOAT[] = {  {&_swigt__p_FIX__FLOAT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Factor[] = {  {&_swigt__p_FIX__Factor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FairValue[] = {  {&_swigt__p_FIX__FairValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FeeMultiplier[] = {  {&_swigt__p_FIX__FeeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldBase[] = {  {&_swigt__p_FIX__CFICode, _p_FIX__CFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegCFICode, _p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearFormat, _p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartCash, _p_FIX__StartCashTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, _p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, _p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasure, _p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasure, _p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasure, _p_FIX__UnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasure, _p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasure, _p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeID, _p_FIX__OrigTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FirmTradeID, _p_FIX__FirmTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeID, _p_FIX__TradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeID, _p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigSecondaryTradeID, _p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Yield, _p_FIX__YieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityType, _p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityType, _p_FIX__SecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpirationQtyType, _p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Account, _p_FIX__AccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingAccount, _p_FIX__ClearingAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocAccount, _p_FIX__LegAllocAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccount, _p_FIX__AllocAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDImplicitDelete, _p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegTimeUnit, _p_FIX__LegTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeUnit, _p_FIX__TimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeTimeUnit, _p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTimeUnit, _p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbID, _p_FIX__StandInstDbIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotifyBrokerOfCredit, _p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BrokerOfCredit, _p_FIX__BrokerOfCreditTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecuritySubType, _p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, _p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdSubType, _p_FIX__TrdSubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeleteReason, _p_FIX__DeleteReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DKReason, _p_FIX__DKReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkRequestID, _p_FIX__NetworkRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarginExcess, _p_FIX__MarginExcessTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRejReasonText, _p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTradeTime, _p_FIX__ContraTradeTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoEvents, _p_FIX__NoEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeEvents, _p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideLastQty, _p_FIX__SideLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCalculatedCcyLastQty, _p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastQty, _p_FIX__LegLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSumField, _p_FIX__CheckSumFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Username, _p_FIX__UsernameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintRptID, _p_FIX__PosMaintRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContIntRptID, _p_FIX__ContIntRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeValue, _p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeValue, _p_FIX__StrikeValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayoutType, _p_FIX__OptPayoutTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedText, _p_FIX__EncodedTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GapFillFlag, _p_FIX__GapFillFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketDepth, _p_FIX__MarketDepthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StopPx, _p_FIX__StopPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDPriceLevel, _p_FIX__MDPriceLevelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteResponseLevel, _p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldCalcDate, _p_FIX__YieldCalcDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollRptID, _p_FIX__CollRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegNumber, _p_FIX__LegNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosType, _p_FIX__PosTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtType, _p_FIX__ContAmtTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosAmtType, _p_FIX__PosAmtTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstID, _p_FIX__SettlInstIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportedPx, _p_FIX__ReportedPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastFragment, _p_FIX__LastFragmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryPriceLimitType, _p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionLimitType, _p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegStipulations, _p_FIX__NoLegStipulationsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStipulations, _p_FIX__NoStipulationsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ShortQty, _p_FIX__ShortQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SellerDays, _p_FIX__SellerDaysTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RptSeq, _p_FIX__RptSeqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetType, _p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegOffsetType, _p_FIX__PegOffsetTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesEndTime, _p_FIX__TradSesEndTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventEndTime, _p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TierCode, _p_FIX__TierCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransferReason, _p_FIX__TransferReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRejectReason, _p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRequestRejectReason, _p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionRejectReason, _p_FIX__SessionRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListRejectReason, _p_FIX__ListRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnReason, _p_FIX__CollAsgnReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRejectReason, _p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportRejectReason, _p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnRejReason, _p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryRejectReason, _p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelRejectReason, _p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStatusRejReason, _p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlRejReason, _p_FIX__CxlRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmRejReason, _p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionRejectReason, _p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrdIDReason, _p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReqRejReason, _p_FIX__MDReqRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BusinessRejectReason, _p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocText, _p_FIX__AllocTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedAllocText, _p_FIX__EncodedAllocTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToSubID, _p_FIX__DeliverToSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeCurr, _p_FIX__MiscFeeCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligMsgID, _p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportedPxDiff, _p_FIX__ReportedPxDiffTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEvents, _p_FIX__NoComplexEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedInstrAttrib, _p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrAttrib, _p_FIX__NoInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrAttrib, _p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrdRepIndicators, _p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStatsIndicators, _p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteSets, _p_FIX__NoQuoteSetsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BeginSeqNo, _p_FIX__BeginSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventPx, _p_FIX__EventPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventPx, _p_FIX__DerivativeEventPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingEvent, _p_FIX__SecurityTradingEventTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossType, _p_FIX__CrossTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndStrikePxRange, _p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartStrikePxRange, _p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementDesc, _p_FIX__AgreementDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketSegmentDesc, _p_FIX__MarketSegmentDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderDelay, _p_FIX__OrderDelayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCategory, _p_FIX__OrderCategoryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsCategory, _p_FIX__NewsCategoryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinQty, _p_FIX__MinQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardNumber, _p_FIX__CardNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctNumber, _p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPositions, _p_FIX__NoPositionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDates, _p_FIX__NoDatesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardStartDate, _p_FIX__CardStartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartDate, _p_FIX__StartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventStartDate, _p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefreshQty, _p_FIX__RefreshQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTime, _p_FIX__OrigTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDUpdateType, _p_FIX__MDUpdateTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDQuoteType, _p_FIX__MDQuoteTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteType, _p_FIX__QuoteTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumBidders, _p_FIX__NumBiddersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementDate, _p_FIX__AgreementDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventDate, _p_FIX__EventDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, _p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentDate, _p_FIX__PaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CouponPaymentDate, _p_FIX__CouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventDate, _p_FIX__DerivativeEventDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCouponPaymentDate, _p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdType, _p_FIX__TrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTrdType, _p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMsgTypes, _p_FIX__NoMsgTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerOrderType, _p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterType, _p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OwnerType, _p_FIX__OwnerTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlSessSubID, _p_FIX__SettlSessSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFlowScheduleType, _p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFlowScheduleType, _p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlowScheduleType, _p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeBasis, _p_FIX__MiscFeeBasisTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedTextLen, _p_FIX__EncodedTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedAllocTextLen, _p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListStatusTextLen, _p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesEvent, _p_FIX__TradSesEventTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayQty, _p_FIX__DisplayQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryDisplayQty, _p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumTradeReports, _p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideSettlCurrency, _p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, _p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveCurrency, _p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocSettlCurrency, _p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlCurrency, _p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingCurrency, _p_FIX__TradingCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeCurrency, _p_FIX__StrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrency, _p_FIX__SettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Currency, _p_FIX__CurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCurrency, _p_FIX__LegCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideCurrency, _p_FIX__SideCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementCurrency, _p_FIX__AgreementCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeCurrency, _p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikeCurrency, _p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CommCurrency, _p_FIX__CommCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettleOnOpenFlag, _p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, _p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocaleOfIssue, _p_FIX__LocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCountryOfIssue, _p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, _p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, _p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCountryOfIssue, _p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StateOrProvinceOfIssue, _p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CountryOfIssue, _p_FIX__CountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeLocaleOfIssue, _p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, _p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlInst, _p_FIX__NoSettlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTradingSessions, _p_FIX__NoTradingSessionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlQty, _p_FIX__CxlQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExecInstRules, _p_FIX__NoExecInstRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeBracket, _p_FIX__TimeBracketTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstMode, _p_FIX__SettlInstModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseError, _p_FIX__ApplResponseErrorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HaltReasonInt, _p_FIX__HaltReasonIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListNoOrds, _p_FIX__ListNoOrdsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlmntTyp, _p_FIX__LegSettlmntTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlmntTyp, _p_FIX__SettlmntTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvRefID, _p_FIX__AdvRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingUnit, _p_FIX__BookingUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastPx, _p_FIX__LastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastPx, _p_FIX__LegLastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLastPx, _p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PrevClosePx, _p_FIX__PrevClosePxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReportID, _p_FIX__MDReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityReportID, _p_FIX__SecurityReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReportID, _p_FIX__ApplReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionReportID, _p_FIX__MassActionReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketReportID, _p_FIX__MarketReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegReportID, _p_FIX__LegReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportID, _p_FIX__TradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportID, _p_FIX__AllocReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTradeReportID, _p_FIX__SideTradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegs, _p_FIX__NoLegsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CancellationRights, _p_FIX__CancellationRightsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXML, _p_FIX__SecurityXMLTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXML, _p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMatchRules, _p_FIX__NoMatchRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RawData, _p_FIX__RawDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocHandlInst, _p_FIX__AllocHandlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HandlInst, _p_FIX__HandlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdType, _p_FIX__OrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Factor, _p_FIX__FactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFactor, _p_FIX__UnderlyingFactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFactor, _p_FIX__LegFactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchType, _p_FIX__MatchTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IssueDate, _p_FIX__IssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIssueDate, _p_FIX__LegIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerType, _p_FIX__TriggerTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingAmounts, _p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidID, _p_FIX__BidIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlType, _p_FIX__SettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlType, _p_FIX__LegSettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityIndType, _p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmType, _p_FIX__ConfirmTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAvgPx, _p_FIX__AllocAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityReqID, _p_FIX__SecurityReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollApplType, _p_FIX__CollApplTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashMargin, _p_FIX__CashMarginTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPx, _p_FIX__AvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAllocationPercent, _p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderPercent, _p_FIX__OrderPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossPercent, _p_FIX__CrossPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStartTime, _p_FIX__TradSesStartTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventStartTime, _p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInstLen, _p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, _p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyRole, _p_FIX__PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyRole, _p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyRole, _p_FIX__TargetPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, _p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCreditRating, _p_FIX__LegCreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CreditRating, _p_FIX__CreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCreditRating, _p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashType, _p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmReqID, _p_FIX__ConfirmReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRpts, _p_FIX__NoRptsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoBidDescriptors, _p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDividendYield, _p_FIX__LegDividendYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DividendYield, _p_FIX__DividendYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseID, _p_FIX__ApplResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegModel, _p_FIX__MultilegModelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTradeQty, _p_FIX__ContraTradeQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InViewOfCommon, _p_FIX__InViewOfCommonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossPrioritization, _p_FIX__CrossPrioritizationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayLowQty, _p_FIX__DisplayLowQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSource, _p_FIX__RateSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListTypeSource, _p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligSource, _p_FIX__SettlObligSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskTypeSource, _p_FIX__DeskTypeSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCoveredOrUncovered, _p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CoveredOrUncovered, _p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteReqID, _p_FIX__QuoteReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPutOrCall, _p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctNum, _p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, _p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbName, _p_FIX__StandInstDbNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskFreeRate, _p_FIX__RiskFreeRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRespID, _p_FIX__QuoteRespIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPrice, _p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionPrice, _p_FIX__DiscretionPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlType, _p_FIX__CxlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CPRegType, _p_FIX__CPRegTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCPRegType, _p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRefID, _p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExpiration, _p_FIX__NoExpirationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeToExpiration, _p_FIX__TimeToExpirationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OwnershipType, _p_FIX__OwnershipTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStipType, _p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceProtectionScope, _p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionScope, _p_FIX__MassActionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionScope, _p_FIX__DiscretionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResponseDestination, _p_FIX__ResponseDestinationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDestination, _p_FIX__ExDestinationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Designation, _p_FIX__DesignationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesOpenTime, _p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingStips, _p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PeggedRefPrice, _p_FIX__PeggedRefPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOptionRatio, _p_FIX__LegOptionRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarginRatio, _p_FIX__MarginRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Urgency, _p_FIX__UrgencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentRef, _p_FIX__PaymentRefTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeForPhysical, _p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefOfferSize, _p_FIX__DefOfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSize, _p_FIX__OfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinOfferSize, _p_FIX__MinOfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDesc, _p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RFQReqID, _p_FIX__RFQReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideQty, _p_FIX__SideQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrAmt, _p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrAmt, _p_FIX__SettlCurrAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlData, _p_FIX__XmlDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumTickets, _p_FIX__NumTicketsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOINaturalFlag, _p_FIX__IOINaturalFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteCondition, _p_FIX__QuoteConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidYield, _p_FIX__BidYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MidYield, _p_FIX__MidYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetGrossInd, _p_FIX__NetGrossIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecValuationPoint, _p_FIX__ExecValuationPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffectedOrderID, _p_FIX__AffectedOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderID, _p_FIX__OrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffectedOrderID, _p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReferencePage, _p_FIX__ReferencePageTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityIDSource, _p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyIDSource, _p_FIX__PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InputSource, _p_FIX__InputSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityIDSource, _p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityIDSource, _p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityAltIDSource, _p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyIDSource, _p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIDSource, _p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityAltIDSource, _p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, _p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDestinationIDSource, _p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderHandlingInstSource, _p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityIDSource, _p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityIDSource, _p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AcctIDSource, _p_FIX__AcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyIDSource, _p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyIDSource, _p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IDSource, _p_FIX__IDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyIDSource, _p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyIDSource, _p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityIDSource, _p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstSource, _p_FIX__SettlInstSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeInputSource, _p_FIX__TradeInputSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrderIDSource, _p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyIDSource, _p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocAcctIDSource, _p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, _p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, _p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplTotalMessageCount, _p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FairValue, _p_FIX__FairValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterValue, _p_FIX__StrategyParameterValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegalConfirm, _p_FIX__LegalConfirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractSettlMonth, _p_FIX__ContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractSettlMonth, _p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractSettlMonth, _p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteID, _p_FIX__QuoteIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransBkdTime, _p_FIX__TransBkdTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollRespID, _p_FIX__CollRespIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampType, _p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampType, _p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationValue, _p_FIX__LegStipulationValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StipulationValue, _p_FIX__StipulationValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CharField, _p_FIX__CharFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MidPx, _p_FIX__MidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMode, _p_FIX__TradSesModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Country, _p_FIX__CountryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryDate, _p_FIX__MDEntryDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Rule80A, _p_FIX__Rule80ATo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentParties, _p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LongQty, _p_FIX__LongQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSwapType, _p_FIX__LegSwapTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillQty, _p_FIX__FillQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingModulus, _p_FIX__RoundingModulusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkType, _p_FIX__AllocLinkTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportType, _p_FIX__AllocReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReportType, _p_FIX__ApplReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPassword, _p_FIX__EncryptedPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewPassword, _p_FIX__NewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementType, _p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventType, _p_FIX__EventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventType, _p_FIX__ComplexEventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccountType, _p_FIX__AllocAccountTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccountType, _p_FIX__AccountTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdjustmentType, _p_FIX__AdjustmentTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventType, _p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RespondentType, _p_FIX__RespondentTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate2, _p_FIX__FutSettDate2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceDelta, _p_FIX__PriceDeltaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValue1, _p_FIX__SideValue1To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValue2, _p_FIX__SideValue2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbol, _p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSymbol, _p_FIX__PegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Symbol, _p_FIX__SymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderQty2, _p_FIX__OrderQty2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AltMDSourceID, _p_FIX__AltMDSourceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoQuoteEntries, _p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntries, _p_FIX__NoMDEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotQuoteEntries, _p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteEntries, _p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__VenueType, _p_FIX__VenueTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerNewQty, _p_FIX__TriggerNewQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeInForce, _p_FIX__TimeInForceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTimeInForce, _p_FIX__SideTimeInForceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstMsgID, _p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvSide, _p_FIX__AdvSideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDate2, _p_FIX__SettlDate2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigOrdModTime, _p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueDepth, _p_FIX__ApplQueueDepthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FieldBase, 0, 0, 0},  {&_swigt__p_FIX__MatchAlgorithm, _p_FIX__MatchAlgorithmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Signature, _p_FIX__SignatureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Text, _p_FIX__TextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Pool, _p_FIX__PoolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SendingDate, _p_FIX__SendingDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistID, _p_FIX__RegistIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewSeqNo, _p_FIX__NewSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMaturityRules, _p_FIX__NoMaturityRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeType, _p_FIX__MiscFeeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryDate, _p_FIX__DeliveryDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValidUntilTime, _p_FIX__ValidUntilTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteSetValidUntilTime, _p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClientBidID, _p_FIX__ClientBidIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDesc, _p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListDesc, _p_FIX__SecurityListDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParentMktSegmID, _p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatsType, _p_FIX__StatsTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityPctHigh, _p_FIX__LiquidityPctHighTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideReasonCd, _p_FIX__SideReasonCdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSymbol, _p_FIX__TriggerSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSides, _p_FIX__NoSidesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryTime, _p_FIX__MDEntryTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportToExch, _p_FIX__ReportToExchTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Subject, _p_FIX__SubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueMax, _p_FIX__ApplQueueMaxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FundRenewWaiv, _p_FIX__FundRenewWaivTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetSubID, _p_FIX__TargetSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceTimeType, _p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferPx, _p_FIX__OfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPool, _p_FIX__LegPoolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDFeedTypes, _p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidPx, _p_FIX__BidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndMaturityMonthYear, _p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, _p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoIOIQualifiers, _p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteQualifiers, _p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDOriginType, _p_FIX__MDOriginTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderQty, _p_FIX__OrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOrderQty, _p_FIX__LegOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashOrderQty, _p_FIX__CashOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayOrderQty, _p_FIX__DayOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeInputDevice, _p_FIX__TradeInputDeviceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderInputDevice, _p_FIX__OrderInputDeviceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoutingID, _p_FIX__RoutingIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, _p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityAltID, _p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, _p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SendingTime, _p_FIX__SendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSendingTime, _p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigSendingTime, _p_FIX__OrigSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopSendingTime, _p_FIX__HopSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecInst, _p_FIX__ExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDepositoryCode, _p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradedFlatSwitch, _p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdLinkID, _p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccruedInterestRate, _p_FIX__AccruedInterestRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureData, _p_FIX__SecureDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEncoding, _p_FIX__MessageEncodingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpireDate, _p_FIX__ExpireDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisFeatureDate, _p_FIX__BasisFeatureDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayWhen, _p_FIX__DisplayWhenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCompIDs, _p_FIX__NoCompIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingRefID, _p_FIX__BookingRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WtAverageLiquidity, _p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceImprovement, _p_FIX__PriceImprovementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdSubTyp, _p_FIX__SideTrdSubTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecType, _p_FIX__ExecTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MailingDtls, _p_FIX__MailingDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HaltReasonChar, _p_FIX__HaltReasonCharTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ModelType, _p_FIX__ModelTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventText, _p_FIX__EventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerNewPrice, _p_FIX__TriggerNewPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingFirm, _p_FIX__ClearingFirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlementCycleNo, _p_FIX__SettlementCycleNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransactTime, _p_FIX__TransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, _p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, _p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasureQty, _p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsRefID, _p_FIX__NewsRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryType, _p_FIX__MDEntryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgParPx, _p_FIX__AvgParPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQltyInd, _p_FIX__IOIQltyIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistDtls, _p_FIX__RegistDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRegistDtls, _p_FIX__NoRegistDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GTBookingInst, _p_FIX__GTBookingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustOrderHandlingInst, _p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MailingInst, _p_FIX__MailingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayBookingInst, _p_FIX__DayBookingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPrice, _p_FIX__LegPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplVerID, _p_FIX__RefApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CstmApplVerID, _p_FIX__CstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultApplVerID, _p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefCstmApplVerID, _p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplVerID, _p_FIX__ApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultCstmApplVerID, _p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DateOfBirth, _p_FIX__DateOfBirthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastMsgSeqNumProcessed, _p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligRefID, _p_FIX__SettlObligRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRefID, _p_FIX__LegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraLegRefID, _p_FIX__ContraLegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLegRefID, _p_FIX__TradeLegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRateSources, _p_FIX__NoRateSourcesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotionalPercentageOutstanding, _p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashOutstanding, _p_FIX__CashOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, _p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, _p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdMatchID, _p_FIX__TrdMatchIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToCompID, _p_FIX__DeliverToCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocPrice, _p_FIX__AllocPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StringField, _p_FIX__StringFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlInstType, _p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInstType, _p_FIX__ListExecInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInstType, _p_FIX__DlvyInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionID, _p_FIX__TradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionID, _p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionID, _p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegScope, _p_FIX__PegScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoAccQuotes, _p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryID, _p_FIX__CollInquiryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecRefID, _p_FIX__ExecRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlRejResponseTo, _p_FIX__CxlRejResponseToTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Price, _p_FIX__PriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LotType, _p_FIX__LotTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampSrc, _p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EmailType, _p_FIX__EmailTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegOptAttribute, _p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptAttribute, _p_FIX__OptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingOptAttribute, _p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOptAttribute, _p_FIX__LegOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlLocation, _p_FIX__SettlLocationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EffectiveTime, _p_FIX__EffectiveTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqID, _p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteCancelType, _p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Scope, _p_FIX__ScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpireTime, _p_FIX__ExpireTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlBrkrCode, _p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreTradeAnonymity, _p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoutingType, _p_FIX__RoutingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideMultiLegReportingType, _p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingType, _p_FIX__BookingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRestructuringType, _p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultiLegReportingType, _p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatusValue, _p_FIX__StatusValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessValue, _p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrdRegTimestamps, _p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryType, _p_FIX__DeliveryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDeliveryType, _p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PrivateQuote, _p_FIX__PrivateQuoteTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedHeadlineLen, _p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisPxType, _p_FIX__BasisPxTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityRuleID, _p_FIX__MaturityRuleIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeRuleID, _p_FIX__StrikeRuleIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteMsgID, _p_FIX__QuoteMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskType, _p_FIX__DeskTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterName, _p_FIX__StrategyParameterNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardHolderName, _p_FIX__CardHolderNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RptSys, _p_FIX__RptSysTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegQty, _p_FIX__LegQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoSecurityTypes, _p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefCompID, _p_FIX__RefCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopCompID, _p_FIX__HopCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfCompID, _p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListStatusType, _p_FIX__ListStatusTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDBookType, _p_FIX__MDBookTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSubBookType, _p_FIX__MDSubBookTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityRequestType, _p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListRequestType, _p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRequestType, _p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListType, _p_FIX__SecurityListTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestType, _p_FIX__TradeRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestType, _p_FIX__UserRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkRequestType, _p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SubscriptionRequestType, _p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelRequestType, _p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuerLen, _p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuerLen, _p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, _p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, _p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoRejQuotes, _p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoCxldQuotes, _p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProductComplex, _p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProductComplex, _p_FIX__ProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustOrderCapacity, _p_FIX__CustOrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCustOrderCapacity, _p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocCustomerCapacity, _p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastCapacity, _p_FIX__LastCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DealingCapacity, _p_FIX__DealingCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCapacity, _p_FIX__OrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistEmail, _p_FIX__RegistEmailTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndSeqNo, _p_FIX__EndSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubID, _p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, _p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartySubID, _p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartySubID, _p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, _p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartySubID, _p_FIX__SettlPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartySubID, _p_FIX__PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartySubID, _p_FIX__RootPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartySubID, _p_FIX__NestedPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartySubID, _p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnAckType, _p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampOrigin, _p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribPayRef, _p_FIX__CashDistribPayRefTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistAcctType, _p_FIX__RegistAcctTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPercentage, _p_FIX__DistribPercentageTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMarketSegments, _p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIOthSvc, _p_FIX__IOIOthSvcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeRule, _p_FIX__ExchangeRuleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReceivedDeptID, _p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefTagID, _p_FIX__RefTagIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProgRptReqs, _p_FIX__ProgRptReqsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CcyAmt, _p_FIX__CcyAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListSeqNo, _p_FIX__ListSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LowPx, _p_FIX__LowPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustDirectedOrder, _p_FIX__CustDirectedOrderTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDStreamID, _p_FIX__MDStreamIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySize, _p_FIX__MDEntrySizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategyPerformance, _p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoHops, _p_FIX__NoHopsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EFPTrackingError, _p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktBidPx, _p_FIX__MktBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxFloor, _p_FIX__MaxFloorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocInterestAtMaturity, _p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAtMaturity, _p_FIX__InterestAtMaturityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideExecID, _p_FIX__SideExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Spread, _p_FIX__SpreadTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSecSizeType, _p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustomerOrFirm, _p_FIX__CustomerOrFirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, _p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDescLen, _p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDescLen, _p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidDescriptorType, _p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMiscFees, _p_FIX__NoMiscFeesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDate, _p_FIX__ExDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegMoveType, _p_FIX__PegMoveTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionMoveType, _p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Price2, _p_FIX__Price2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClientID, _p_FIX__ClientIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RawDataLength, _p_FIX__RawDataLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BodyLength, _p_FIX__BodyLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SignatureLength, _p_FIX__SignatureLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoClearingInstructions, _p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderRestrictions, _p_FIX__OrderRestrictionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeSpecialInstructions, _p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySeller, _p_FIX__MDEntrySellerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSecSize, _p_FIX__MDSecSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinLotSize, _p_FIX__MinLotSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDay, _p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityDay, _p_FIX__MaturityDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionResponse, _p_FIX__MassActionResponseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelResponse, _p_FIX__MassCancelResponseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideFillStationCd, _p_FIX__SideFillStationCdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocShares, _p_FIX__AllocSharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Shares, _p_FIX__SharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIShares, _p_FIX__IOISharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyID, _p_FIX__Nested4PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyID, _p_FIX__PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyID, _p_FIX__RootPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueResolution, _p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayAvgPx, _p_FIX__DayAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLLen, _p_FIX__SecurityXMLLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLLen, _p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRoutingIDs, _p_FIX__NoRoutingIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryID, _p_FIX__MDEntryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryID, _p_FIX__QuoteEntryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillExecID, _p_FIX__FillExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InvestorCountryOfResidence, _p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefreshIndicator, _p_FIX__RefreshIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultVerIndicator, _p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRepIndicator, _p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PublishTrdIndicator, _p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradePublishIndicator, _p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CopyMsgIndicator, _p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ImpliedMarketIndicator, _p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnsolicitedIndicator, _p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AutoAcceptIndicator, _p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, _p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPxIndicator, _p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TestMessageIndicator, _p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WorkingIndicator, _p_FIX__WorkingIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ManualOrderIndicator, _p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraryInstructionIndicator, _p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReversalIndicator, _p_FIX__ReversalIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorityIndicator, _p_FIX__PriorityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlexProductEligibilityIndicator, _p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AggressorIndicator, _p_FIX__AggressorIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocClearingFeeIndicator, _p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingFeeIndicator, _p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsOfIndicator, _p_FIX__AsOfIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTradingSessionRules, _p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplID, _p_FIX__ApplIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementID, _p_FIX__AgreementIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketSegmentID, _p_FIX__MarketSegmentIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPrice, _p_FIX__ComplexEventPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraBroker, _p_FIX__ContraBrokerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecBroker, _p_FIX__ExecBrokerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRateCalc, _p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRateCalc, _p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportRefID, _p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintRptRefID, _p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpirationCycle, _p_FIX__ExpirationCycleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResetSeqNumFlag, _p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideLiquidityInd, _p_FIX__SideLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastLiquidityInd, _p_FIX__LastLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillLiquidityInd, _p_FIX__FillLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIssuer, _p_FIX__LegIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuer, _p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeIssuer, _p_FIX__DerivativeIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIssuer, _p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuer, _p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Issuer, _p_FIX__IssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionDesc, _p_FIX__TradingSessionDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqType, _p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocIntermedReqType, _p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReqType, _p_FIX__ApplReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastShares, _p_FIX__LastSharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillPx, _p_FIX__FillPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRate, _p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityExchange, _p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, _p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityExchange, _p_FIX__SecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityExchange, _p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldType, _p_FIX__YieldTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardIssNo, _p_FIX__CardIssNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingEndPrice, _p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocQty, _p_FIX__AllocQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocQty, _p_FIX__LegAllocQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmID, _p_FIX__ConfirmIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartySubIDType, _p_FIX__PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubIDType, _p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartySubIDType, _p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, _p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, _p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartySubIDType, _p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartySubIDType, _p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartySubIDType, _p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartySubIDType, _p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SolicitedFlag, _p_FIX__SolicitedFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeAmt, _p_FIX__MiscFeeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RedemptionDate, _p_FIX__RedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeOriginationDate, _p_FIX__TradeOriginationDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRedemptionDate, _p_FIX__LegRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRedemptionDate, _p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionDate, _p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListStatusText, _p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListStatusText, _p_FIX__ListStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatusText, _p_FIX__StatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserStatusText, _p_FIX__UserStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OutsideIndexPct, _p_FIX__OutsideIndexPctTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPosAmt, _p_FIX__NoPosAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosAmt, _p_FIX__PosAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Headline, _p_FIX__HeadlineTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedHeadline, _p_FIX__EncodedHeadlineTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AttachmentPoint, _p_FIX__AttachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DetachmentPoint, _p_FIX__DetachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAttachmentPoint, _p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDetachmentPoint, _p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedDate, _p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DatedDate, _p_FIX__DatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQty, _p_FIX__IOIQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIOIQty, _p_FIX__LegIOIQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastRptRequested, _p_FIX__LastRptRequestedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponRate, _p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CouponRate, _p_FIX__CouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCouponRate, _p_FIX__LegCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplID, _p_FIX__RefApplIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSideTrdRegTS, _p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LowLimitPrice, _p_FIX__LowLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStartValue, _p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrentValue, _p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoApplIDs, _p_FIX__NoApplIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentName, _p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentName, _p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentName, _p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRefID, _p_FIX__RegistRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BusinessRejectRefID, _p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstRefID, _p_FIX__SettlInstRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListRefID, _p_FIX__SecurityListRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCapPrice, _p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CapPrice, _p_FIX__CapPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IntField, _p_FIX__IntFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactPhone, _p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, _p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RejectText, _p_FIX__RejectTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundLot, _p_FIX__RoundLotTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopRefID, _p_FIX__HopRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingExerciseStyle, _p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExerciseStyle, _p_FIX__LegExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrikes, _p_FIX__NoStrikesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoStrikes, _p_FIX__TotNoStrikesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OddLot, _p_FIX__OddLotTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSum, _p_FIX__CheckSumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferYield, _p_FIX__OfferYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PeggedPrice, _p_FIX__PeggedPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingEndValue, _p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToLocationID, _p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfLocationID, _p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetLocationID, _p_FIX__TargetLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocationID, _p_FIX__LocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderLocationID, _p_FIX__SenderLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__URLLink, _p_FIX__URLLinkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribCurr, _p_FIX__CashDistribCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityStatusReqID, _p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqID, _p_FIX__PosReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesReqID, _p_FIX__TradSesReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassStatusReqID, _p_FIX__MassStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProgPeriodInterval, _p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalTakedown, _p_FIX__TotalTakedownTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepurchaseRate, _p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepurchaseRate, _p_FIX__RepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseRate, _p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastParPx, _p_FIX__LastParPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDistribInsts, _p_FIX__NoDistribInstsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityPctLow, _p_FIX__LiquidityPctLowTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardIssNum, _p_FIX__CardIssNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefMsgType, _p_FIX__RefMsgTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgType, _p_FIX__MsgTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoFills, _p_FIX__NoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesCloseTime, _p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesPreCloseTime, _p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayHighQty, _p_FIX__DisplayHighQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidDescriptor, _p_FIX__BidDescriptorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecInstValue, _p_FIX__ExecInstValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegOffsetValue, _p_FIX__PegOffsetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtValue, _p_FIX__ContAmtValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetValue, _p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNetValue, _p_FIX__TotalNetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIid, _p_FIX__IOIidTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeTime, _p_FIX__StrikeTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRejReasonCode, _p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ForexReq, _p_FIX__ForexReqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Side, _p_FIX__SideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDMkt, _p_FIX__MDMktTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlSessID, _p_FIX__SettlSessIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, _p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LanguageCode, _p_FIX__LanguageCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubjectLen, _p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsRefType, _p_FIX__NewsRefTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedTime, _p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WaveNo, _p_FIX__WaveNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTraded, _p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContraBrokers, _p_FIX__NoContraBrokersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OutMainCntryUIndex, _p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HighPx, _p_FIX__HighPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BoolField, _p_FIX__BoolFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPx, _p_FIX__UnderlyingPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsID, _p_FIX__NewsIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTrader, _p_FIX__ContraTraderTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrades, _p_FIX__NoTradesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessPct, _p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Volatility, _p_FIX__VolatilityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegVolatility, _p_FIX__LegVolatilityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNewsRefIDs, _p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtCurr, _p_FIX__ContAmtCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbType, _p_FIX__StandInstDbTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingInstruction, _p_FIX__ClearingInstructionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastMkt, _p_FIX__LastMktTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityResponseType, _p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseType, _p_FIX__ApplResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkStatusResponseType, _p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryAllocID, _p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocID, _p_FIX__IndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefAllocID, _p_FIX__RefAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryIndividualAllocID, _p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocID, _p_FIX__LegAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIndividualAllocID, _p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocID, _p_FIX__AllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EmailThreadID, _p_FIX__EmailThreadIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SellVolume, _p_FIX__SellVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityDesc, _p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityDesc, _p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityDesc, _p_FIX__PegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, _p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityDesc, _p_FIX__SecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, _p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDesc, _p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEventTimes, _p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardExpDate, _p_FIX__CardExpDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndAccruedInterestAmt, _p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalAccruedInterestAmt, _p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccruedInterestAmt, _p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccruedInterestAmt, _p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, _p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, _p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractMultiplierUnit, _p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractMultiplierUnit, _p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSide, _p_FIX__LegSideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDate, _p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityDate, _p_FIX__LegMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityDate, _p_FIX__QuantityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityDate, _p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegDifference, _p_FIX__PegDifferenceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CorporateAction, _p_FIX__CorporateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesUpdateAction, _p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityUpdateAction, _p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListUpdateAction, _p_FIX__ListUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketUpdateAction, _p_FIX__MarketUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDUpdateAction, _p_FIX__MDUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueAction, _p_FIX__ApplQueueActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionInst, _p_FIX__DiscretionInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreviouslyReported, _p_FIX__PreviouslyReportedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinTradeVol, _p_FIX__MinTradeVolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxTradeVol, _p_FIX__MaxTradeVolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessCurr, _p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecAckStatus, _p_FIX__ExecAckStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MoneyLaunderingStatus, _p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplSeqNum, _p_FIX__ApplSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefSeqNum, _p_FIX__RefSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplLastSeqNum, _p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplLastSeqNum, _p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplEndSeqNum, _p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingQty, _p_FIX__UnderlyingQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderBookingQty, _p_FIX__OrderBookingQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCPProgram, _p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CPProgram, _p_FIX__CPProgramTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryPx, _p_FIX__MDEntryPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvTransType, _p_FIX__AdvTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligTransType, _p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnTransType, _p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportTransType, _p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmTransType, _p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosTransType, _p_FIX__PosTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastForwardPoints2, _p_FIX__LastForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints2, _p_FIX__OfferForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidForwardPoints2, _p_FIX__BidForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnID, _p_FIX__CollAsgnIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenClose, _p_FIX__OpenCloseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocPositionEffect, _p_FIX__AllocPositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPositionEffect, _p_FIX__LegPositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionEffect, _p_FIX__PositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IncTaxInd, _p_FIX__IncTaxIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepurchaseTerm, _p_FIX__RepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepurchaseTerm, _p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, _p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatdSym, _p_FIX__RelatdSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenCloseSettleFlag, _p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplExtID, _p_FIX__ApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultApplExtID, _p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplExtID, _p_FIX__RefApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderSubID, _p_FIX__SenderSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligMode, _p_FIX__SettlObligModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentRemitterID, _p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidType, _p_FIX__BidTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionSubID, _p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionSubID, _p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, _p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketID, _p_FIX__MarketIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TaxAdvantageType, _p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlDetails, _p_FIX__NoSettlDetailsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RndPx, _p_FIX__RndPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CumQty, _p_FIX__CumQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryPositionNo, _p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAffectedOrders, _p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalAffectedOrders, _p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNotAffectedOrders, _p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumberOfOrders, _p_FIX__NumberOfOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnType, _p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityRequestResult, _p_FIX__SecurityRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintResult, _p_FIX__PosMaintResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerAction, _p_FIX__TriggerActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAction, _p_FIX__CollActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintAction, _p_FIX__PosMaintActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndCash, _p_FIX__EndCashTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefSubID, _p_FIX__RefSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSubID, _p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDirtyPrice, _p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCapacityQty, _p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityID, _p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityID, _p_FIX__LegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityID, _p_FIX__SecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityID, _p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityID, _p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserStatus, _p_FIX__UserStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRptStatus, _p_FIX__TrdRptStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchStatus, _p_FIX__MatchStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdStatus, _p_FIX__OrdStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistStatus, _p_FIX__RegistStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultiLegRptTypeReq, _p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityTime, _p_FIX__MaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityTime, _p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTickRules, _p_FIX__NoTickRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingBusinessDate, _p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeNTPositionLimit, _p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionLimit, _p_FIX__PositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NTPositionLimit, _p_FIX__NTPositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePositionLimit, _p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteSetID, _p_FIX__QuoteSetIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvId, _p_FIX__AdvIdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Quantity, _p_FIX__QuantityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, _p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeOptPayAmount, _p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDeliveryAmount, _p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayAmount, _p_FIX__OptPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmRefID, _p_FIX__ConfirmRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SharedCommission, _p_FIX__SharedCommissionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Commission, _p_FIX__CommissionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffset, _p_FIX__DiscretionOffsetTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIRefID, _p_FIX__IOIRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisFeaturePrice, _p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocateReqd, _p_FIX__LocateReqdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Concession, _p_FIX__ConcessionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CommType, _p_FIX__CommTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxPriceVariation, _p_FIX__MaxPriceVariationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeHandlingInstr, _p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeHandlingInstr, _p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDFeedType, _p_FIX__MDFeedTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceTypeScope, _p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestamp, _p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestamp, _p_FIX__TrdRegTimestampTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetChgPrevDay, _p_FIX__NetChgPrevDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpQty, _p_FIX__ExpQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AssignmentUnit, _p_FIX__AssignmentUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceQuoteMethod, _p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceQuoteMethod, _p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreallocMethod, _p_FIX__PreallocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExerciseMethod, _p_FIX__ExerciseMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayMethod, _p_FIX__DisplayMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoBidComponents, _p_FIX__NoBidComponentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityValue, _p_FIX__LiquidityValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListName, _p_FIX__ListNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PctAtRisk, _p_FIX__PctAtRiskTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeOnlyField, _p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoRelatedSym, _p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedSym, _p_FIX__NoRelatedSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, _p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReqID, _p_FIX__MDReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCurrencyRatio, _p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CurrencyRatio, _p_FIX__CurrencyRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocNetMoney, _p_FIX__AllocNetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetMoney, _p_FIX__NetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityNetMoney, _p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveName, _p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveName, _p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigPosReqRefID, _p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RatioQty, _p_FIX__RatioQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRatioQty, _p_FIX__LegRatioQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AggregatedBook, _p_FIX__AggregatedBookTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurvePoint, _p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurvePoint, _p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayoutAmount, _p_FIX__OptPayoutAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCollectAmount, _p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexOptPayoutAmount, _p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ThresholdAmount, _p_FIX__ThresholdAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenCloseSettlFlag, _p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResendFlag, _p_FIX__ApplResendFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayMinIncr, _p_FIX__DisplayMinIncrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxShow, _p_FIX__MaxShowTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExecs, _p_FIX__NoExecsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRate, _p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrOfferFxRate, _p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrBidFxRate, _p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskID, _p_FIX__DeskIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryForm, _p_FIX__DeliveryFormTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossID, _p_FIX__CrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategy, _p_FIX__TargetStrategyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactName, _p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctName, _p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctName, _p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctName, _p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactName, _p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfSecSizes, _p_FIX__NoOfSecSizesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FirstPx, _p_FIX__FirstPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPrxPrecision, _p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPxPrecision, _p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegStrikePrice, _p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikePrice, _p_FIX__LegStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikePrice, _p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradingReferencePrice, _p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikePrice, _p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePrice, _p_FIX__StrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingReferencePrice, _p_FIX__TradingReferencePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, _p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryBuyer, _p_FIX__MDEntryBuyerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlDate, _p_FIX__LegSettlDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDate, _p_FIX__SettlDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndDate, _p_FIX__EndDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TestReqID, _p_FIX__TestReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketReqID, _p_FIX__MarketReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqID, _p_FIX__SettlInstReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventEndDate, _p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LeavesQty, _p_FIX__LeavesQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIID, _p_FIX__IOIIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribType, _p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribType, _p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrAttribType, _p_FIX__InstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProcessCode, _p_FIX__ProcessCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcDateField, _p_FIX__UtcDateFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DoubleField, _p_FIX__DoubleFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValueOfFutures, _p_FIX__ValueOfFuturesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinBidSize, _p_FIX__MinBidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefBidSize, _p_FIX__DefBidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSize, _p_FIX__BidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpType, _p_FIX__ExpTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastUpdateTime, _p_FIX__LastUpdateTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossDupFlag, _p_FIX__PossDupFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlMethod, _p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, _p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValuationMethod, _p_FIX__ValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FuturesValuationMethod, _p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeValuationMethod, _p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AssignmentMethod, _p_FIX__AssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlMethod, _p_FIX__SettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, _p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrmtAssignmentMethod, _p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSettlMethod, _p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxMessageSize, _p_FIX__MaxMessageSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSwapPoints, _p_FIX__LastSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidForwardPoints, _p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastForwardPoints, _p_FIX__LastForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SwapPoints, _p_FIX__SwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastForwardPoints, _p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferForwardPoints, _p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSwapPoints, _p_FIX__BidSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSwapPoints, _p_FIX__OfferSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidForwardPoints, _p_FIX__BidForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryForwardPoints, _p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints, _p_FIX__OfferForwardPointsTo_p_FIX__FieldBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldConvertError[] = {  {&_swigt__p_FIX__FieldConvertError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap[] = {  {&_swigt__p_FIX__Group, _p_FIX__GroupTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Header, _p_FIX__HeaderTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Trailer, _p_FIX__TrailerTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Message, _p_FIX__MessageTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__FieldMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap__Fields__const_iterator[] = {  {&_swigt__p_FIX__FieldMap__Fields__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap__Groups__const_iterator[] = {  {&_swigt__p_FIX__FieldMap__Groups__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldNotFound[] = {  {&_swigt__p_FIX__FieldNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileLog[] = {  {&_swigt__p_FIX__FileLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileLogFactory[] = {  {&_swigt__p_FIX__FileLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileStore[] = {  {&_swigt__p_FIX__FileStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileStoreFactory[] = {  {&_swigt__p_FIX__FileStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillExecID[] = {  {&_swigt__p_FIX__FillExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillLiquidityInd[] = {  {&_swigt__p_FIX__FillLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillPx[] = {  {&_swigt__p_FIX__FillPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillQty[] = {  {&_swigt__p_FIX__FillQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FinancialStatus[] = {  {&_swigt__p_FIX__FinancialStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FirmTradeID[] = {  {&_swigt__p_FIX__FirmTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FirstPx[] = {  {&_swigt__p_FIX__FirstPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlexProductEligibilityIndicator[] = {  {&_swigt__p_FIX__FlexProductEligibilityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlexibleIndicator[] = {  {&_swigt__p_FIX__FlexibleIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FloorPrice[] = {  {&_swigt__p_FIX__FloorPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlowScheduleType[] = {  {&_swigt__p_FIX__FlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ForexReq[] = {  {&_swigt__p_FIX__ForexReq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FundRenewWaiv[] = {  {&_swigt__p_FIX__FundRenewWaiv, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FutSettDate[] = {  {&_swigt__p_FIX__FutSettDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FutSettDate2[] = {  {&_swigt__p_FIX__FutSettDate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FuturesValuationMethod[] = {  {&_swigt__p_FIX__FuturesValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GTBookingInst[] = {  {&_swigt__p_FIX__GTBookingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GapFillFlag[] = {  {&_swigt__p_FIX__GapFillFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GrossTradeAmt[] = {  {&_swigt__p_FIX__GrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Group[] = {  {&_swigt__p_FIX__Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HaltReasonChar[] = {  {&_swigt__p_FIX__HaltReasonChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HaltReasonInt[] = {  {&_swigt__p_FIX__HaltReasonInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HandlInst[] = {  {&_swigt__p_FIX__HandlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Header[] = {  {&_swigt__p_FIX__Header, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Headline[] = {  {&_swigt__p_FIX__Headline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HeartBtInt[] = {  {&_swigt__p_FIX__HeartBtInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HighLimitPrice[] = {  {&_swigt__p_FIX__HighLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HighPx[] = {  {&_swigt__p_FIX__HighPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopCompID[] = {  {&_swigt__p_FIX__HopCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopRefID[] = {  {&_swigt__p_FIX__HopRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopSendingTime[] = {  {&_swigt__p_FIX__HopSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HostCrossID[] = {  {&_swigt__p_FIX__HostCrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IDSource[] = {  {&_swigt__p_FIX__IDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__INT[] = {  {&_swigt__p_FIX__INT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOException[] = {  {&_swigt__p_FIX__IOException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIID[] = {  {&_swigt__p_FIX__IOIID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOINaturalFlag[] = {  {&_swigt__p_FIX__IOINaturalFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIOthSvc[] = {  {&_swigt__p_FIX__IOIOthSvc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQltyInd[] = {  {&_swigt__p_FIX__IOIQltyInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQty[] = {  {&_swigt__p_FIX__IOIQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQualifier[] = {  {&_swigt__p_FIX__IOIQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIRefID[] = {  {&_swigt__p_FIX__IOIRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIShares[] = {  {&_swigt__p_FIX__IOIShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOITransType[] = {  {&_swigt__p_FIX__IOITransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIid[] = {  {&_swigt__p_FIX__IOIid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ImpliedMarketIndicator[] = {  {&_swigt__p_FIX__ImpliedMarketIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InViewOfCommon[] = {  {&_swigt__p_FIX__InViewOfCommon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncTaxInd[] = {  {&_swigt__p_FIX__IncTaxInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectDataFormat[] = {  {&_swigt__p_FIX__IncorrectDataFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectMessageStructure[] = {  {&_swigt__p_FIX__IncorrectMessageStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectTagValue[] = {  {&_swigt__p_FIX__IncorrectTagValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocID[] = {  {&_swigt__p_FIX__IndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocRejCode[] = {  {&_swigt__p_FIX__IndividualAllocRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocType[] = {  {&_swigt__p_FIX__IndividualAllocType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Initiator[] = {  {&_swigt__p_FIX__Initiator, 0, 0, 0},  {&_swigt__p_FIX__SocketInitiator, _p_FIX__SocketInitiatorTo_p_FIX__Initiator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InputSource[] = {  {&_swigt__p_FIX__InputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrAttribType[] = {  {&_swigt__p_FIX__InstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrAttribValue[] = {  {&_swigt__p_FIX__InstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrRegistry[] = {  {&_swigt__p_FIX__InstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrmtAssignmentMethod[] = {  {&_swigt__p_FIX__InstrmtAssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyID[] = {  {&_swigt__p_FIX__InstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyIDSource[] = {  {&_swigt__p_FIX__InstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyRole[] = {  {&_swigt__p_FIX__InstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartySubID[] = {  {&_swigt__p_FIX__InstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartySubIDType[] = {  {&_swigt__p_FIX__InstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IntField[] = {  {&_swigt__p_FIX__NoNewsRefIDs, _p_FIX__NoNewsRefIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPositions, _p_FIX__NoPositionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMiscFees, _p_FIX__NoMiscFeesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ClearingInstruction, _p_FIX__ClearingInstructionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventTimes, _p_FIX__NoComplexEventTimesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDSecSizeType, _p_FIX__MDSecSizeTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RepurchaseTerm, _p_FIX__RepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegRepurchaseTerm, _p_FIX__LegRepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, _p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RptSeq, _p_FIX__RptSeqTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumBidders, _p_FIX__NumBiddersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultilegModel, _p_FIX__MultilegModelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDPriceLevel, _p_FIX__MDPriceLevelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteResponseLevel, _p_FIX__QuoteResponseLevelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OptPayoutType, _p_FIX__OptPayoutTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContractMultiplierUnit, _p_FIX__ContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplierUnit, _p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, _p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, _p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplEndSeqNum, _p_FIX__ApplEndSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefApplLastSeqNum, _p_FIX__RefApplLastSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplLastSeqNum, _p_FIX__ApplLastSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefSeqNum, _p_FIX__RefSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplSeqNum, _p_FIX__ApplSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExecInstRules, _p_FIX__NoExecInstRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoQuoteEntries, _p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDEntries, _p_FIX__NoMDEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotQuoteEntries, _p_FIX__TotQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteEntries, _p_FIX__NoQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HopRefID, _p_FIX__HopRefIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SessionRejectReason, _p_FIX__SessionRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListRejectReason, _p_FIX__ListRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionRejectReason, _p_FIX__MassActionRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmRejReason, _p_FIX__ConfirmRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CxlRejReason, _p_FIX__CxlRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRejReason, _p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryRejectReason, _p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportRejectReason, _p_FIX__TradeReportRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRejectReason, _p_FIX__QuoteRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnReason, _p_FIX__CollAsgnReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassCancelRejectReason, _p_FIX__MassCancelRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatusRejReason, _p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRequestRejectReason, _p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnRejectReason, _p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefOrdIDReason, _p_FIX__RefOrdIDReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BusinessRejectReason, _p_FIX__BusinessRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContraBrokers, _p_FIX__NoContraBrokersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlementCycleNo, _p_FIX__SettlementCycleNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrdRegTimestamps, _p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAffectedOrders, _p_FIX__NoAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalAffectedOrders, _p_FIX__TotalAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNotAffectedOrders, _p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumberOfOrders, _p_FIX__NumberOfOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoApplIDs, _p_FIX__NoApplIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueResolution, _p_FIX__ApplQueueResolutionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPrxPrecision, _p_FIX__AvgPrxPrecisionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPxPrecision, _p_FIX__AvgPxPrecisionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RegistRejReasonCode, _p_FIX__RegistRejReasonCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MiscFeeBasis, _p_FIX__MiscFeeBasisTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListStatusType, _p_FIX__ListStatusTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteSets, _p_FIX__NoQuoteSetsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpType, _p_FIX__ExpTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedIssuerLen, _p_FIX__EncodedIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuerLen, _p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, _p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, _p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeliveryForm, _p_FIX__DeliveryFormTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionLimitType, _p_FIX__DiscretionLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecondaryPriceLimitType, _p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTradingSessions, _p_FIX__NoTradingSessionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IncTaxInd, _p_FIX__IncTaxIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampType, _p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampType, _p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, _p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMatchRules, _p_FIX__NoMatchRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityRequestType, _p_FIX__SecurityRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestType, _p_FIX__TradeRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UserRequestType, _p_FIX__UserRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetworkRequestType, _p_FIX__NetworkRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListType, _p_FIX__SecurityListTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRequestType, _p_FIX__QuoteRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListRequestType, _p_FIX__SecurityListRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StatsType, _p_FIX__StatsTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocSettlInstType, _p_FIX__AllocSettlInstTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingPutOrCall, _p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceTimeType, _p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityIndType, _p_FIX__LiquidityIndTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradePublishIndicator, _p_FIX__TradePublishIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ImpliedMarketIndicator, _p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPxIndicator, _p_FIX__AvgPxIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriorityIndicator, _p_FIX__PriorityIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRptStatus, _p_FIX__TrdRptStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UserStatus, _p_FIX__UserStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegExerciseStyle, _p_FIX__LegExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingExerciseStyle, _p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CustOrderCapacity, _p_FIX__CustOrderCapacityTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrigCustOrderCapacity, _p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlInst, _p_FIX__NoSettlInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IntField, 0, 0, 0},  {&_swigt__p_FIX__ListSeqNo, _p_FIX__ListSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxMessageSize, _p_FIX__MaxMessageSizeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MarketDepth, _p_FIX__MarketDepthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplResponseError, _p_FIX__ApplResponseErrorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollApplType, _p_FIX__CollApplTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__GTBookingInst, _p_FIX__GTBookingInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumTickets, _p_FIX__NumTicketsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegSwapType, _p_FIX__LegSwapTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelay, _p_FIX__OrderDelayTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrades, _p_FIX__NoTradesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityXMLLen, _p_FIX__SecurityXMLLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLLen, _p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearFormat, _p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteCancelType, _p_FIX__QuoteCancelTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ModelType, _p_FIX__ModelTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocReportType, _p_FIX__AllocReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplReportType, _p_FIX__ApplReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultiLegRptTypeReq, _p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoHops, _p_FIX__NoHopsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CrossType, _p_FIX__CrossTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRateSources, _p_FIX__NoRateSourcesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__FlowScheduleType, _p_FIX__FlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegFlowScheduleType, _p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeFlowScheduleType, _p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyRole, _p_FIX__PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, _p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested2PartyRole, _p_FIX__Nested2PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TargetPartyRole, _p_FIX__TargetPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, _p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDescLen, _p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, _p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDescLen, _p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlObligMode, _p_FIX__SettlObligModeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegNumber, _p_FIX__LegNumberTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StatusValue, _p_FIX__StatusValueTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideQty, _p_FIX__SideQtyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideLiquidityInd, _p_FIX__SideLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LastLiquidityInd, _p_FIX__LastLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__FillLiquidityInd, _p_FIX__FillLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StandInstDbType, _p_FIX__StandInstDbTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMarketSegments, _p_FIX__NoMarketSegmentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TargetStrategy, _p_FIX__TargetStrategyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionMoveType, _p_FIX__DiscretionMoveTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegMoveType, _p_FIX__PegMoveTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPosAmt, _p_FIX__NoPosAmtTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListNoOrds, _p_FIX__ListNoOrdsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSideTrdRegTS, _p_FIX__NoSideTrdRegTSTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoFills, _p_FIX__NoFillsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedHeadlineLen, _p_FIX__EncodedHeadlineLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedListExecInstLen, _p_FIX__EncodedListExecInstLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SellerDays, _p_FIX__SellerDaysTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LastMsgSeqNumProcessed, _p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRegistDtls, _p_FIX__NoRegistDtlsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMsgTypes, _p_FIX__NoMsgTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDBookType, _p_FIX__MDBookTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDSubBookType, _p_FIX__MDSubBookTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrAttrib, _p_FIX__NoInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedInstrAttrib, _p_FIX__NoNestedInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrAttrib, _p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCompIDs, _p_FIX__NoCompIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExpiration, _p_FIX__NoExpirationTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrumentParties, _p_FIX__NoInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegs, _p_FIX__NoLegsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideTrdSubTyp, _p_FIX__SideTrdSubTypTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoBidComponents, _p_FIX__NoBidComponentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegOffsetType, _p_FIX__PegOffsetTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetType, _p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CustomerOrFirm, _p_FIX__CustomerOrFirmTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesMode, _p_FIX__TradSesModeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegScope, _p_FIX__PegScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityReportID, _p_FIX__SecurityReportIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDReportID, _p_FIX__MDReportIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocLinkType, _p_FIX__AllocLinkTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingAmounts, _p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoClearingInstructions, _p_FIX__NoClearingInstructionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDQuoteType, _p_FIX__MDQuoteTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDUpdateType, _p_FIX__MDUpdateTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteType, _p_FIX__QuoteTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnAckType, _p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMaturityRules, _p_FIX__NoMaturityRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideLastQty, _p_FIX__SideLastQtyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumTradeReports, _p_FIX__TotNumTradeReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CoveredOrUncovered, _p_FIX__CoveredOrUncoveredTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegCoveredOrUncovered, _p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTradingSessionRules, _p_FIX__NoTradingSessionRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesEvent, _p_FIX__TradSesEventTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpirationQtyType, _p_FIX__ExpirationQtyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlDetails, _p_FIX__NoSettlDetailsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CPProgram, _p_FIX__CPProgramTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplTotalMessageCount, _p_FIX__ApplTotalMessageCountTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityResponseType, _p_FIX__SecurityResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplResponseType, _p_FIX__ApplResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueDepth, _p_FIX__ApplQueueDepthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetworkStatusResponseType, _p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEvents, _p_FIX__NoComplexEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EventType, _p_FIX__EventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventType, _p_FIX__ComplexEventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocAccountType, _p_FIX__AllocAccountTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RespondentType, _p_FIX__RespondentTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AccountType, _p_FIX__AccountTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AdjustmentType, _p_FIX__AdjustmentTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEventType, _p_FIX__DerivativeEventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoEvents, _p_FIX__NoEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeEvents, _p_FIX__NoDerivativeEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementType, _p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AcctIDSource, _p_FIX__AcctIDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderHandlingInstSource, _p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListTypeSource, _p_FIX__SecurityListTypeSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RateSource, _p_FIX__RateSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeskTypeSource, _p_FIX__DeskTypeSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BidType, _p_FIX__BidTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDates, _p_FIX__NoDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrategyParameterType, _p_FIX__StrategyParameterTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OwnerType, _p_FIX__OwnerTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSides, _p_FIX__NoSidesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeNTPositionLimit, _p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDOriginType, _p_FIX__MDOriginTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PositionLimit, _p_FIX__PositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NTPositionLimit, _p_FIX__NTPositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CrossPrioritization, _p_FIX__CrossPrioritizationTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativePositionLimit, _p_FIX__DerivativePositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoRejQuotes, _p_FIX__TotNoRejQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoCxldQuotes, _p_FIX__TotNoCxldQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocHandlInst, _p_FIX__AllocHandlInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDFeedTypes, _p_FIX__NoMDFeedTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoAccQuotes, _p_FIX__TotNoAccQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoBidDescriptors, _p_FIX__NoBidDescriptorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrdRepIndicators, _p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStatsIndicators, _p_FIX__NoStatsIndicatorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegStipulations, _p_FIX__NoLegStipulationsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStipulations, _p_FIX__NoStipulationsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDistribInsts, _p_FIX__NoDistribInstsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EndSeqNo, _p_FIX__EndSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRpts, _p_FIX__NoRptsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingEvent, _p_FIX__SecurityTradingEventTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdSubType, _p_FIX__TrdSubTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ProgRptReqs, _p_FIX__ProgRptReqsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ProgPeriodInterval, _p_FIX__ProgPeriodIntervalTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoSecurityTypes, _p_FIX__TotNoSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContAmtType, _p_FIX__ContAmtTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnTransType, _p_FIX__CollAsgnTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportTransType, _p_FIX__TradeReportTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionResponse, _p_FIX__MassActionResponseTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmTransType, _p_FIX__ConfirmTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosTransType, _p_FIX__PosTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BidDescriptorType, _p_FIX__BidDescriptorTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TaxAdvantageType, _p_FIX__TaxAdvantageTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested2PartySubIDType, _p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, _p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, _p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartySubIDType, _p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested3PartySubIDType, _p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartySubIDType, _p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartySubIDType, _p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubIDType, _p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartySubIDType, _p_FIX__PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedTextLen, _p_FIX__EncodedTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedAllocTextLen, _p_FIX__EncodedAllocTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedListStatusTextLen, _p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteQualifiers, _p_FIX__NoQuoteQualifiersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoIOIQualifiers, _p_FIX__NoIOIQualifiersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDEntryPositionNo, _p_FIX__MDEntryPositionNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BeginSeqNo, _p_FIX__BeginSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocIntermedReqType, _p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqType, _p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplReqType, _p_FIX__ApplReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSubjectLen, _p_FIX__EncodedSubjectLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeliveryType, _p_FIX__DeliveryTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlDeliveryType, _p_FIX__SettlDeliveryTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewsCategory, _p_FIX__NewsCategoryTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdType, _p_FIX__TrdTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecondaryTrdType, _p_FIX__SecondaryTrdTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoRelatedSym, _p_FIX__TotNoRelatedSymTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedSym, _p_FIX__NoRelatedSymTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpirationCycle, _p_FIX__ExpirationCycleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueMax, _p_FIX__ApplQueueMaxTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAction, _p_FIX__CollActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintAction, _p_FIX__PosMaintActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewsRefType, _p_FIX__NewsRefTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueAction, _p_FIX__ApplQueueActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionScope, _p_FIX__MassActionScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionScope, _p_FIX__DiscretionScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribType, _p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribType, _p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrAttribType, _p_FIX__InstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetGrossInd, _p_FIX__NetGrossIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTickRules, _p_FIX__NoTickRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOfSecSizes, _p_FIX__NoOfSecSizesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnType, _p_FIX__StreamAsgnTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrikes, _p_FIX__NoStrikesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoStrikes, _p_FIX__TotNoStrikesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefTagID, _p_FIX__RefTagIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExecs, _p_FIX__NoExecsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideMultiLegReportingType, _p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RoutingType, _p_FIX__RoutingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BookingType, _p_FIX__BookingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityRequestResult, _p_FIX__SecurityRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintResult, _p_FIX__PosMaintResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RawDataLength, _p_FIX__RawDataLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BodyLength, _p_FIX__BodyLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SignatureLength, _p_FIX__SignatureLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplExtID, _p_FIX__ApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DefaultApplExtID, _p_FIX__DefaultApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefApplExtID, _p_FIX__RefApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRoutingIDs, _p_FIX__NoRoutingIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewSeqNo, _p_FIX__NewSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, _p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HaltReasonInt, _p_FIX__HaltReasonIntTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingStips, _p_FIX__NoUnderlyingStipsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmType, _p_FIX__ConfirmTypeTo_p_FIX__IntField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InterestAccrualDate[] = {  {&_swigt__p_FIX__InterestAccrualDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InterestAtMaturity[] = {  {&_swigt__p_FIX__InterestAtMaturity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidMessage[] = {  {&_swigt__p_FIX__InvalidMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidMessageType[] = {  {&_swigt__p_FIX__InvalidMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidTagNumber[] = {  {&_swigt__p_FIX__InvalidTagNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvestorCountryOfResidence[] = {  {&_swigt__p_FIX__InvestorCountryOfResidence, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IssueDate[] = {  {&_swigt__p_FIX__IssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Issuer[] = {  {&_swigt__p_FIX__Issuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LANGUAGE[] = {  {&_swigt__p_FIX__LANGUAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LENGTH[] = {  {&_swigt__p_FIX__LENGTH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LOCALMKTDATE[] = {  {&_swigt__p_FIX__LOCALMKTDATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LanguageCode[] = {  {&_swigt__p_FIX__LanguageCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastCapacity[] = {  {&_swigt__p_FIX__LastCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastForwardPoints[] = {  {&_swigt__p_FIX__LastForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastForwardPoints2[] = {  {&_swigt__p_FIX__LastForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastFragment[] = {  {&_swigt__p_FIX__LastFragment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastLiquidityInd[] = {  {&_swigt__p_FIX__LastLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastMkt[] = {  {&_swigt__p_FIX__LastMkt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastMsgSeqNumProcessed[] = {  {&_swigt__p_FIX__LastMsgSeqNumProcessed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastNetworkResponseID[] = {  {&_swigt__p_FIX__LastNetworkResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastParPx[] = {  {&_swigt__p_FIX__LastParPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastPx[] = {  {&_swigt__p_FIX__LastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastQty[] = {  {&_swigt__p_FIX__LastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastRptRequested[] = {  {&_swigt__p_FIX__LastRptRequested, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastShares[] = {  {&_swigt__p_FIX__LastShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastSpotRate[] = {  {&_swigt__p_FIX__LastSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastSwapPoints[] = {  {&_swigt__p_FIX__LastSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastUpdateTime[] = {  {&_swigt__p_FIX__LastUpdateTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LateIndicator[] = {  {&_swigt__p_FIX__LateIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LeavesQty[] = {  {&_swigt__p_FIX__LeavesQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocAccount[] = {  {&_swigt__p_FIX__LegAllocAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocAcctIDSource[] = {  {&_swigt__p_FIX__LegAllocAcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocID[] = {  {&_swigt__p_FIX__LegAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocQty[] = {  {&_swigt__p_FIX__LegAllocQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocSettlCurrency[] = {  {&_swigt__p_FIX__LegAllocSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurveCurrency[] = {  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurveName[] = {  {&_swigt__p_FIX__LegBenchmarkCurveName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurvePoint[] = {  {&_swigt__p_FIX__LegBenchmarkCurvePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkPrice[] = {  {&_swigt__p_FIX__LegBenchmarkPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkPriceType[] = {  {&_swigt__p_FIX__LegBenchmarkPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBidForwardPoints[] = {  {&_swigt__p_FIX__LegBidForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBidPx[] = {  {&_swigt__p_FIX__LegBidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCFICode[] = {  {&_swigt__p_FIX__LegCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCalculatedCcyLastQty[] = {  {&_swigt__p_FIX__LegCalculatedCcyLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractMultiplier[] = {  {&_swigt__p_FIX__LegContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractMultiplierUnit[] = {  {&_swigt__p_FIX__LegContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractSettlMonth[] = {  {&_swigt__p_FIX__LegContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCountryOfIssue[] = {  {&_swigt__p_FIX__LegCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCouponPaymentDate[] = {  {&_swigt__p_FIX__LegCouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCouponRate[] = {  {&_swigt__p_FIX__LegCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCoveredOrUncovered[] = {  {&_swigt__p_FIX__LegCoveredOrUncovered, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCreditRating[] = {  {&_swigt__p_FIX__LegCreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCurrency[] = {  {&_swigt__p_FIX__LegCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCurrencyRatio[] = {  {&_swigt__p_FIX__LegCurrencyRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegDatedDate[] = {  {&_swigt__p_FIX__LegDatedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegDividendYield[] = {  {&_swigt__p_FIX__LegDividendYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegExecInst[] = {  {&_swigt__p_FIX__LegExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegExerciseStyle[] = {  {&_swigt__p_FIX__LegExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFactor[] = {  {&_swigt__p_FIX__LegFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFlowScheduleType[] = {  {&_swigt__p_FIX__LegFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFutSettDate[] = {  {&_swigt__p_FIX__LegFutSettDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegGrossTradeAmt[] = {  {&_swigt__p_FIX__LegGrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIOIQty[] = {  {&_swigt__p_FIX__LegIOIQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIndividualAllocID[] = {  {&_swigt__p_FIX__LegIndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegInstrRegistry[] = {  {&_swigt__p_FIX__LegInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegInterestAccrualDate[] = {  {&_swigt__p_FIX__LegInterestAccrualDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIssueDate[] = {  {&_swigt__p_FIX__LegIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIssuer[] = {  {&_swigt__p_FIX__LegIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastForwardPoints[] = {  {&_swigt__p_FIX__LegLastForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastPx[] = {  {&_swigt__p_FIX__LegLastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastQty[] = {  {&_swigt__p_FIX__LegLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLocaleOfIssue[] = {  {&_swigt__p_FIX__LegLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityDate[] = {  {&_swigt__p_FIX__LegMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityMonthYear[] = {  {&_swigt__p_FIX__LegMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityTime[] = {  {&_swigt__p_FIX__LegMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegNumber[] = {  {&_swigt__p_FIX__LegNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOfferForwardPoints[] = {  {&_swigt__p_FIX__LegOfferForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOfferPx[] = {  {&_swigt__p_FIX__LegOfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOptAttribute[] = {  {&_swigt__p_FIX__LegOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOptionRatio[] = {  {&_swigt__p_FIX__LegOptionRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOrderQty[] = {  {&_swigt__p_FIX__LegOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPool[] = {  {&_swigt__p_FIX__LegPool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPositionEffect[] = {  {&_swigt__p_FIX__LegPositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPrice[] = {  {&_swigt__p_FIX__LegPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceType[] = {  {&_swigt__p_FIX__LegPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceUnitOfMeasure[] = {  {&_swigt__p_FIX__LegPriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegProduct[] = {  {&_swigt__p_FIX__LegProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPutOrCall[] = {  {&_swigt__p_FIX__LegPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegQty[] = {  {&_swigt__p_FIX__LegQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRatioQty[] = {  {&_swigt__p_FIX__LegRatioQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRedemptionDate[] = {  {&_swigt__p_FIX__LegRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRefID[] = {  {&_swigt__p_FIX__LegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepoCollateralSecurityType[] = {  {&_swigt__p_FIX__LegRepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegReportID[] = {  {&_swigt__p_FIX__LegReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepurchaseRate[] = {  {&_swigt__p_FIX__LegRepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepurchaseTerm[] = {  {&_swigt__p_FIX__LegRepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityAltID[] = {  {&_swigt__p_FIX__LegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityAltIDSource[] = {  {&_swigt__p_FIX__LegSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityDesc[] = {  {&_swigt__p_FIX__LegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityExchange[] = {  {&_swigt__p_FIX__LegSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityID[] = {  {&_swigt__p_FIX__LegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityIDSource[] = {  {&_swigt__p_FIX__LegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecuritySubType[] = {  {&_swigt__p_FIX__LegSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityType[] = {  {&_swigt__p_FIX__LegSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlCurrency[] = {  {&_swigt__p_FIX__LegSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlDate[] = {  {&_swigt__p_FIX__LegSettlDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlType[] = {  {&_swigt__p_FIX__LegSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlmntTyp[] = {  {&_swigt__p_FIX__LegSettlmntTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSide[] = {  {&_swigt__p_FIX__LegSide, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStipulationType[] = {  {&_swigt__p_FIX__LegStipulationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStipulationValue[] = {  {&_swigt__p_FIX__LegStipulationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStrikeCurrency[] = {  {&_swigt__p_FIX__LegStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStrikePrice[] = {  {&_swigt__p_FIX__LegStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSwapType[] = {  {&_swigt__p_FIX__LegSwapType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSymbol[] = {  {&_swigt__p_FIX__LegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSymbolSfx[] = {  {&_swigt__p_FIX__LegSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegTimeUnit[] = {  {&_swigt__p_FIX__LegTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegUnitOfMeasure[] = {  {&_swigt__p_FIX__LegUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegUnitOfMeasureQty[] = {  {&_swigt__p_FIX__LegUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegVolatility[] = {  {&_swigt__p_FIX__LegVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegalConfirm[] = {  {&_swigt__p_FIX__LegalConfirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LinesOfText[] = {  {&_swigt__p_FIX__LinesOfText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityIndType[] = {  {&_swigt__p_FIX__LiquidityIndType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityNumSecurities[] = {  {&_swigt__p_FIX__LiquidityNumSecurities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityPctHigh[] = {  {&_swigt__p_FIX__LiquidityPctHigh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityPctLow[] = {  {&_swigt__p_FIX__LiquidityPctLow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityValue[] = {  {&_swigt__p_FIX__LiquidityValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListExecInst[] = {  {&_swigt__p_FIX__ListExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListExecInstType[] = {  {&_swigt__p_FIX__ListExecInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListID[] = {  {&_swigt__p_FIX__ListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListMethod[] = {  {&_swigt__p_FIX__ListMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListName[] = {  {&_swigt__p_FIX__ListName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListNoOrds[] = {  {&_swigt__p_FIX__ListNoOrds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListOrderStatus[] = {  {&_swigt__p_FIX__ListOrderStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListRejectReason[] = {  {&_swigt__p_FIX__ListRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListSeqNo[] = {  {&_swigt__p_FIX__ListSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListStatusText[] = {  {&_swigt__p_FIX__ListStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListStatusType[] = {  {&_swigt__p_FIX__ListStatusType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListUpdateAction[] = {  {&_swigt__p_FIX__ListUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocaleOfIssue[] = {  {&_swigt__p_FIX__LocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocateReqd[] = {  {&_swigt__p_FIX__LocateReqd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocationID[] = {  {&_swigt__p_FIX__LocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Log[] = {  {&_swigt__p_FIX__NullLog, _p_FIX__NullLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__Log, 0, 0, 0},  {&_swigt__p_FIX__FileLog, _p_FIX__FileLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__ScreenLog, _p_FIX__ScreenLogTo_p_FIX__Log, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LogFactory[] = {  {&_swigt__p_FIX__LogFactory, 0, 0, 0},  {&_swigt__p_FIX__ScreenLogFactory, _p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory, 0, 0},  {&_swigt__p_FIX__FileLogFactory, _p_FIX__FileLogFactoryTo_p_FIX__LogFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LongQty[] = {  {&_swigt__p_FIX__LongQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LotType[] = {  {&_swigt__p_FIX__LotType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LowLimitPrice[] = {  {&_swigt__p_FIX__LowLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LowPx[] = {  {&_swigt__p_FIX__LowPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDBookType[] = {  {&_swigt__p_FIX__MDBookType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryBuyer[] = {  {&_swigt__p_FIX__MDEntryBuyer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryDate[] = {  {&_swigt__p_FIX__MDEntryDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryForwardPoints[] = {  {&_swigt__p_FIX__MDEntryForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryID[] = {  {&_swigt__p_FIX__MDEntryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryOriginator[] = {  {&_swigt__p_FIX__MDEntryOriginator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryPositionNo[] = {  {&_swigt__p_FIX__MDEntryPositionNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryPx[] = {  {&_swigt__p_FIX__MDEntryPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryRefID[] = {  {&_swigt__p_FIX__MDEntryRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySeller[] = {  {&_swigt__p_FIX__MDEntrySeller, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySize[] = {  {&_swigt__p_FIX__MDEntrySize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySpotRate[] = {  {&_swigt__p_FIX__MDEntrySpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryTime[] = {  {&_swigt__p_FIX__MDEntryTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryType[] = {  {&_swigt__p_FIX__MDEntryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDFeedType[] = {  {&_swigt__p_FIX__MDFeedType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDImplicitDelete[] = {  {&_swigt__p_FIX__MDImplicitDelete, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDMkt[] = {  {&_swigt__p_FIX__MDMkt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDOriginType[] = {  {&_swigt__p_FIX__MDOriginType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDPriceLevel[] = {  {&_swigt__p_FIX__MDPriceLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDQuoteType[] = {  {&_swigt__p_FIX__MDQuoteType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReportID[] = {  {&_swigt__p_FIX__MDReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReqID[] = {  {&_swigt__p_FIX__MDReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReqRejReason[] = {  {&_swigt__p_FIX__MDReqRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSecSize[] = {  {&_swigt__p_FIX__MDSecSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSecSizeType[] = {  {&_swigt__p_FIX__MDSecSizeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDStreamID[] = {  {&_swigt__p_FIX__MDStreamID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSubBookType[] = {  {&_swigt__p_FIX__MDSubBookType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDUpdateAction[] = {  {&_swigt__p_FIX__MDUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDUpdateType[] = {  {&_swigt__p_FIX__MDUpdateType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MONTHYEAR[] = {  {&_swigt__p_FIX__MONTHYEAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLECHARVALUE[] = {  {&_swigt__p_FIX__MULTIPLECHARVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLESTRINGVALUE[] = {  {&_swigt__p_FIX__MULTIPLESTRINGVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLEVALUESTRING[] = {  {&_swigt__p_FIX__MULTIPLEVALUESTRING, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MailingDtls[] = {  {&_swigt__p_FIX__MailingDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MailingInst[] = {  {&_swigt__p_FIX__MailingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ManualOrderIndicator[] = {  {&_swigt__p_FIX__ManualOrderIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarginExcess[] = {  {&_swigt__p_FIX__MarginExcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarginRatio[] = {  {&_swigt__p_FIX__MarginRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketDepth[] = {  {&_swigt__p_FIX__MarketDepth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketID[] = {  {&_swigt__p_FIX__MarketID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketReportID[] = {  {&_swigt__p_FIX__MarketReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketReqID[] = {  {&_swigt__p_FIX__MarketReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketSegmentDesc[] = {  {&_swigt__p_FIX__MarketSegmentDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketSegmentID[] = {  {&_swigt__p_FIX__MarketSegmentID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketUpdateAction[] = {  {&_swigt__p_FIX__MarketUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionRejectReason[] = {  {&_swigt__p_FIX__MassActionRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionReportID[] = {  {&_swigt__p_FIX__MassActionReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionResponse[] = {  {&_swigt__p_FIX__MassActionResponse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionScope[] = {  {&_swigt__p_FIX__MassActionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionType[] = {  {&_swigt__p_FIX__MassActionType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelRejectReason[] = {  {&_swigt__p_FIX__MassCancelRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelRequestType[] = {  {&_swigt__p_FIX__MassCancelRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelResponse[] = {  {&_swigt__p_FIX__MassCancelResponse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassStatusReqID[] = {  {&_swigt__p_FIX__MassStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassStatusReqType[] = {  {&_swigt__p_FIX__MassStatusReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchAlgorithm[] = {  {&_swigt__p_FIX__MatchAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchIncrement[] = {  {&_swigt__p_FIX__MatchIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchStatus[] = {  {&_swigt__p_FIX__MatchStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchType[] = {  {&_swigt__p_FIX__MatchType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityDate[] = {  {&_swigt__p_FIX__MaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityDay[] = {  {&_swigt__p_FIX__MaturityDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYear[] = {  {&_swigt__p_FIX__MaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearFormat[] = {  {&_swigt__p_FIX__MaturityMonthYearFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearIncrement[] = {  {&_swigt__p_FIX__MaturityMonthYearIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearIncrementUnits[] = {  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityNetMoney[] = {  {&_swigt__p_FIX__MaturityNetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityRuleID[] = {  {&_swigt__p_FIX__MaturityRuleID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityTime[] = {  {&_swigt__p_FIX__MaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxFloor[] = {  {&_swigt__p_FIX__MaxFloor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxMessageSize[] = {  {&_swigt__p_FIX__MaxMessageSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxPriceLevels[] = {  {&_swigt__p_FIX__MaxPriceLevels, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxPriceVariation[] = {  {&_swigt__p_FIX__MaxPriceVariation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxShow[] = {  {&_swigt__p_FIX__MaxShow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxTradeVol[] = {  {&_swigt__p_FIX__MaxTradeVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MemoryStore[] = {  {&_swigt__p_FIX__MemoryStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MemoryStoreFactory[] = {  {&_swigt__p_FIX__MemoryStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Message[] = {  {&_swigt__p_FIX__Message, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageEncoding[] = {  {&_swigt__p_FIX__MessageEncoding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageEventSource[] = {  {&_swigt__p_FIX__MessageEventSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageParseError[] = {  {&_swigt__p_FIX__MessageParseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStore[] = {  {&_swigt__p_FIX__MemoryStore, _p_FIX__MemoryStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__MessageStore, 0, 0, 0},  {&_swigt__p_FIX__FileStore, _p_FIX__FileStoreTo_p_FIX__MessageStore, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreExceptionWrapper[] = {  {&_swigt__p_FIX__MessageStoreExceptionWrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreFactory[] = {  {&_swigt__p_FIX__MessageStoreFactory, 0, 0, 0},  {&_swigt__p_FIX__MemoryStoreFactory, _p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__FileStoreFactory, _p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreFactoryExceptionWrapper[] = {  {&_swigt__p_FIX__MessageStoreFactoryExceptionWrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MidPx[] = {  {&_swigt__p_FIX__MidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MidYield[] = {  {&_swigt__p_FIX__MidYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinBidSize[] = {  {&_swigt__p_FIX__MinBidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinLotSize[] = {  {&_swigt__p_FIX__MinLotSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinOfferSize[] = {  {&_swigt__p_FIX__MinOfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinPriceIncrement[] = {  {&_swigt__p_FIX__MinPriceIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinPriceIncrementAmount[] = {  {&_swigt__p_FIX__MinPriceIncrementAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinQty[] = {  {&_swigt__p_FIX__MinQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinTradeVol[] = {  {&_swigt__p_FIX__MinTradeVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeAmt[] = {  {&_swigt__p_FIX__MiscFeeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeBasis[] = {  {&_swigt__p_FIX__MiscFeeBasis, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeCurr[] = {  {&_swigt__p_FIX__MiscFeeCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeType[] = {  {&_swigt__p_FIX__MiscFeeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MktBidPx[] = {  {&_swigt__p_FIX__MktBidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MktOfferPx[] = {  {&_swigt__p_FIX__MktOfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ModelType[] = {  {&_swigt__p_FIX__ModelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MoneyLaunderingStatus[] = {  {&_swigt__p_FIX__MoneyLaunderingStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgDirection[] = {  {&_swigt__p_FIX__MsgDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgSeqNum[] = {  {&_swigt__p_FIX__MsgSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgType[] = {  {&_swigt__p_FIX__MsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultiLegReportingType[] = {  {&_swigt__p_FIX__MultiLegReportingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultiLegRptTypeReq[] = {  {&_swigt__p_FIX__MultiLegRptTypeReq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultilegModel[] = {  {&_swigt__p_FIX__MultilegModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultilegPriceMethod[] = {  {&_swigt__p_FIX__MultilegPriceMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NTPositionLimit[] = {  {&_swigt__p_FIX__NTPositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NUMINGROUP[] = {  {&_swigt__p_FIX__NUMINGROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyID[] = {  {&_swigt__p_FIX__Nested2PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyIDSource[] = {  {&_swigt__p_FIX__Nested2PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyRole[] = {  {&_swigt__p_FIX__Nested2PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartySubID[] = {  {&_swigt__p_FIX__Nested2PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartySubIDType[] = {  {&_swigt__p_FIX__Nested2PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyID[] = {  {&_swigt__p_FIX__Nested3PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyIDSource[] = {  {&_swigt__p_FIX__Nested3PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyRole[] = {  {&_swigt__p_FIX__Nested3PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartySubID[] = {  {&_swigt__p_FIX__Nested3PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartySubIDType[] = {  {&_swigt__p_FIX__Nested3PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyID[] = {  {&_swigt__p_FIX__Nested4PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyIDSource[] = {  {&_swigt__p_FIX__Nested4PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyRole[] = {  {&_swigt__p_FIX__Nested4PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartySubID[] = {  {&_swigt__p_FIX__Nested4PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartySubIDType[] = {  {&_swigt__p_FIX__Nested4PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedInstrAttribType[] = {  {&_swigt__p_FIX__NestedInstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedInstrAttribValue[] = {  {&_swigt__p_FIX__NestedInstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyID[] = {  {&_swigt__p_FIX__NestedPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyIDSource[] = {  {&_swigt__p_FIX__NestedPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyRole[] = {  {&_swigt__p_FIX__NestedPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartySubID[] = {  {&_swigt__p_FIX__NestedPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartySubIDType[] = {  {&_swigt__p_FIX__NestedPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetChgPrevDay[] = {  {&_swigt__p_FIX__NetChgPrevDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetGrossInd[] = {  {&_swigt__p_FIX__NetGrossInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetMoney[] = {  {&_swigt__p_FIX__NetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkRequestID[] = {  {&_swigt__p_FIX__NetworkRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkRequestType[] = {  {&_swigt__p_FIX__NetworkRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkResponseID[] = {  {&_swigt__p_FIX__NetworkResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkStatusResponseType[] = {  {&_swigt__p_FIX__NetworkStatusResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewPassword[] = {  {&_swigt__p_FIX__NewPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewSeqNo[] = {  {&_swigt__p_FIX__NewSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsCategory[] = {  {&_swigt__p_FIX__NewsCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsID[] = {  {&_swigt__p_FIX__NewsID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsRefID[] = {  {&_swigt__p_FIX__NewsRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsRefType[] = {  {&_swigt__p_FIX__NewsRefType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NextExpectedMsgSeqNum[] = {  {&_swigt__p_FIX__NextExpectedMsgSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAffectedOrders[] = {  {&_swigt__p_FIX__NoAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAllocs[] = {  {&_swigt__p_FIX__NoAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAltMDSource[] = {  {&_swigt__p_FIX__NoAltMDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoApplIDs[] = {  {&_swigt__p_FIX__NoApplIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAsgnReqs[] = {  {&_swigt__p_FIX__NoAsgnReqs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoBidComponents[] = {  {&_swigt__p_FIX__NoBidComponents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoBidDescriptors[] = {  {&_swigt__p_FIX__NoBidDescriptors, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCapacities[] = {  {&_swigt__p_FIX__NoCapacities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoClearingInstructions[] = {  {&_swigt__p_FIX__NoClearingInstructions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCollInquiryQualifier[] = {  {&_swigt__p_FIX__NoCollInquiryQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCompIDs[] = {  {&_swigt__p_FIX__NoCompIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEventDates[] = {  {&_swigt__p_FIX__NoComplexEventDates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEventTimes[] = {  {&_swigt__p_FIX__NoComplexEventTimes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEvents[] = {  {&_swigt__p_FIX__NoComplexEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContAmts[] = {  {&_swigt__p_FIX__NoContAmts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContraBrokers[] = {  {&_swigt__p_FIX__NoContraBrokers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDates[] = {  {&_swigt__p_FIX__NoDates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeEvents[] = {  {&_swigt__p_FIX__NoDerivativeEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrAttrib[] = {  {&_swigt__p_FIX__NoDerivativeInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrumentParties[] = {  {&_swigt__p_FIX__NoDerivativeInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeSecurityAltID[] = {  {&_swigt__p_FIX__NoDerivativeSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDistribInsts[] = {  {&_swigt__p_FIX__NoDistribInsts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDlvyInst[] = {  {&_swigt__p_FIX__NoDlvyInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoEvents[] = {  {&_swigt__p_FIX__NoEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExecInstRules[] = {  {&_swigt__p_FIX__NoExecInstRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExecs[] = {  {&_swigt__p_FIX__NoExecs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExpiration[] = {  {&_swigt__p_FIX__NoExpiration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoFills[] = {  {&_swigt__p_FIX__NoFills, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoHops[] = {  {&_swigt__p_FIX__NoHops, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoIOIQualifiers[] = {  {&_swigt__p_FIX__NoIOIQualifiers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrAttrib[] = {  {&_swigt__p_FIX__NoInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrumentParties[] = {  {&_swigt__p_FIX__NoInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegAllocs[] = {  {&_swigt__p_FIX__NoLegAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegSecurityAltID[] = {  {&_swigt__p_FIX__NoLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegStipulations[] = {  {&_swigt__p_FIX__NoLegStipulations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegs[] = {  {&_swigt__p_FIX__NoLegs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLinesOfText[] = {  {&_swigt__p_FIX__NoLinesOfText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLotTypeRules[] = {  {&_swigt__p_FIX__NoLotTypeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDEntries[] = {  {&_swigt__p_FIX__NoMDEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDEntryTypes[] = {  {&_swigt__p_FIX__NoMDEntryTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDFeedTypes[] = {  {&_swigt__p_FIX__NoMDFeedTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMarketSegments[] = {  {&_swigt__p_FIX__NoMarketSegments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMatchRules[] = {  {&_swigt__p_FIX__NoMatchRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMaturityRules[] = {  {&_swigt__p_FIX__NoMaturityRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMiscFees[] = {  {&_swigt__p_FIX__NoMiscFees, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMsgTypes[] = {  {&_swigt__p_FIX__NoMsgTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested2PartyIDs[] = {  {&_swigt__p_FIX__NoNested2PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested2PartySubIDs[] = {  {&_swigt__p_FIX__NoNested2PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested3PartyIDs[] = {  {&_swigt__p_FIX__NoNested3PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested3PartySubIDs[] = {  {&_swigt__p_FIX__NoNested3PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested4PartyIDs[] = {  {&_swigt__p_FIX__NoNested4PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested4PartySubIDs[] = {  {&_swigt__p_FIX__NoNested4PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedInstrAttrib[] = {  {&_swigt__p_FIX__NoNestedInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedPartyIDs[] = {  {&_swigt__p_FIX__NoNestedPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedPartySubIDs[] = {  {&_swigt__p_FIX__NoNestedPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNewsRefIDs[] = {  {&_swigt__p_FIX__NoNewsRefIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNotAffectedOrders[] = {  {&_swigt__p_FIX__NoNotAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOfLegUnderlyings[] = {  {&_swigt__p_FIX__NoOfLegUnderlyings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOfSecSizes[] = {  {&_swigt__p_FIX__NoOfSecSizes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOrdTypeRules[] = {  {&_swigt__p_FIX__NoOrdTypeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOrders[] = {  {&_swigt__p_FIX__NoOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyIDs[] = {  {&_swigt__p_FIX__NoPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartySubIDs[] = {  {&_swigt__p_FIX__NoPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPosAmt[] = {  {&_swigt__p_FIX__NoPosAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPositions[] = {  {&_swigt__p_FIX__NoPositions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteEntries[] = {  {&_swigt__p_FIX__NoQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteQualifiers[] = {  {&_swigt__p_FIX__NoQuoteQualifiers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteSets[] = {  {&_swigt__p_FIX__NoQuoteSets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRateSources[] = {  {&_swigt__p_FIX__NoRateSources, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRegistDtls[] = {  {&_swigt__p_FIX__NoRegistDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedSym[] = {  {&_swigt__p_FIX__NoRelatedSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRootPartyIDs[] = {  {&_swigt__p_FIX__NoRootPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRootPartySubIDs[] = {  {&_swigt__p_FIX__NoRootPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRoutingIDs[] = {  {&_swigt__p_FIX__NoRoutingIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRpts[] = {  {&_swigt__p_FIX__NoRpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSecurityAltID[] = {  {&_swigt__p_FIX__NoSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSecurityTypes[] = {  {&_swigt__p_FIX__NoSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlDetails[] = {  {&_swigt__p_FIX__NoSettlDetails, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlInst[] = {  {&_swigt__p_FIX__NoSettlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlOblig[] = {  {&_swigt__p_FIX__NoSettlOblig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlPartyIDs[] = {  {&_swigt__p_FIX__NoSettlPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlPartySubIDs[] = {  {&_swigt__p_FIX__NoSettlPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSideTrdRegTS[] = {  {&_swigt__p_FIX__NoSideTrdRegTS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSides[] = {  {&_swigt__p_FIX__NoSides, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStatsIndicators[] = {  {&_swigt__p_FIX__NoStatsIndicators, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStipulations[] = {  {&_swigt__p_FIX__NoStipulations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrategyParameters[] = {  {&_swigt__p_FIX__NoStrategyParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrikeRules[] = {  {&_swigt__p_FIX__NoStrikeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrikes[] = {  {&_swigt__p_FIX__NoStrikes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTagValue[] = {  {&_swigt__p_FIX__NoTagValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTargetPartyIDs[] = {  {&_swigt__p_FIX__NoTargetPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTickRules[] = {  {&_swigt__p_FIX__NoTickRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTimeInForceRules[] = {  {&_swigt__p_FIX__NoTimeInForceRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrades[] = {  {&_swigt__p_FIX__NoTrades, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTradingSessionRules[] = {  {&_swigt__p_FIX__NoTradingSessionRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTradingSessions[] = {  {&_swigt__p_FIX__NoTradingSessions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrdRegTimestamps[] = {  {&_swigt__p_FIX__NoTrdRegTimestamps, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrdRepIndicators[] = {  {&_swigt__p_FIX__NoTrdRepIndicators, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingAmounts[] = {  {&_swigt__p_FIX__NoUnderlyingAmounts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingLegSecurityAltID[] = {  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingSecurityAltID[] = {  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingStips[] = {  {&_swigt__p_FIX__NoUnderlyingStips, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyings[] = {  {&_swigt__p_FIX__NoUnderlyings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUndlyInstrumentParties[] = {  {&_swigt__p_FIX__NoUndlyInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUndlyInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotAffOrigClOrdID[] = {  {&_swigt__p_FIX__NotAffOrigClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotAffectedOrderID[] = {  {&_swigt__p_FIX__NotAffectedOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotifyBrokerOfCredit[] = {  {&_swigt__p_FIX__NotifyBrokerOfCredit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__NotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullApplication[] = {  {&_swigt__p_FIX__NullApplication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullLog[] = {  {&_swigt__p_FIX__NullLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumBidders[] = {  {&_swigt__p_FIX__NumBidders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumDaysInterest[] = {  {&_swigt__p_FIX__NumDaysInterest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumTickets[] = {  {&_swigt__p_FIX__NumTickets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumberOfOrders[] = {  {&_swigt__p_FIX__NumberOfOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OddLot[] = {  {&_swigt__p_FIX__OddLot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferForwardPoints[] = {  {&_swigt__p_FIX__OfferForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferForwardPoints2[] = {  {&_swigt__p_FIX__OfferForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferPx[] = {  {&_swigt__p_FIX__OfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSize[] = {  {&_swigt__p_FIX__OfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSpotRate[] = {  {&_swigt__p_FIX__OfferSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSwapPoints[] = {  {&_swigt__p_FIX__OfferSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferYield[] = {  {&_swigt__p_FIX__OfferYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfCompID[] = {  {&_swigt__p_FIX__OnBehalfOfCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfLocationID[] = {  {&_swigt__p_FIX__OnBehalfOfLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfSendingTime[] = {  {&_swigt__p_FIX__OnBehalfOfSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfSubID[] = {  {&_swigt__p_FIX__OnBehalfOfSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenClose[] = {  {&_swigt__p_FIX__OpenClose, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenCloseSettlFlag[] = {  {&_swigt__p_FIX__OpenCloseSettlFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenCloseSettleFlag[] = {  {&_swigt__p_FIX__OpenCloseSettleFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenInterest[] = {  {&_swigt__p_FIX__OpenInterest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptAttribute[] = {  {&_swigt__p_FIX__OptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayAmount[] = {  {&_swigt__p_FIX__OptPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayoutAmount[] = {  {&_swigt__p_FIX__OptPayoutAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayoutType[] = {  {&_swigt__p_FIX__OptPayoutType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdRejReason[] = {  {&_swigt__p_FIX__OrdRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdStatus[] = {  {&_swigt__p_FIX__OrdStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdStatusReqID[] = {  {&_swigt__p_FIX__OrdStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdType[] = {  {&_swigt__p_FIX__OrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderAvgPx[] = {  {&_swigt__p_FIX__OrderAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderBookingQty[] = {  {&_swigt__p_FIX__OrderBookingQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCapacity[] = {  {&_swigt__p_FIX__OrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCapacityQty[] = {  {&_swigt__p_FIX__OrderCapacityQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCategory[] = {  {&_swigt__p_FIX__OrderCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderDelay[] = {  {&_swigt__p_FIX__OrderDelay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderDelayUnit[] = {  {&_swigt__p_FIX__OrderDelayUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderHandlingInstSource[] = {  {&_swigt__p_FIX__OrderHandlingInstSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderID[] = {  {&_swigt__p_FIX__OrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderInputDevice[] = {  {&_swigt__p_FIX__OrderInputDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderPercent[] = {  {&_swigt__p_FIX__OrderPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderQty[] = {  {&_swigt__p_FIX__OrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderQty2[] = {  {&_swigt__p_FIX__OrderQty2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderRestrictions[] = {  {&_swigt__p_FIX__OrderRestrictions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigClOrdID[] = {  {&_swigt__p_FIX__OrigClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigCrossID[] = {  {&_swigt__p_FIX__OrigCrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigCustOrderCapacity[] = {  {&_swigt__p_FIX__OrigCustOrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigOrdModTime[] = {  {&_swigt__p_FIX__OrigOrdModTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigPosReqRefID[] = {  {&_swigt__p_FIX__OrigPosReqRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigSecondaryTradeID[] = {  {&_swigt__p_FIX__OrigSecondaryTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigSendingTime[] = {  {&_swigt__p_FIX__OrigSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTime[] = {  {&_swigt__p_FIX__OrigTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeDate[] = {  {&_swigt__p_FIX__OrigTradeDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeHandlingInstr[] = {  {&_swigt__p_FIX__OrigTradeHandlingInstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeID[] = {  {&_swigt__p_FIX__OrigTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OriginalNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OutMainCntryUIndex[] = {  {&_swigt__p_FIX__OutMainCntryUIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OutsideIndexPct[] = {  {&_swigt__p_FIX__OutsideIndexPct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OwnerType[] = {  {&_swigt__p_FIX__OwnerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OwnershipType[] = {  {&_swigt__p_FIX__OwnershipType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PERCENTAGE[] = {  {&_swigt__p_FIX__PERCENTAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PRICE[] = {  {&_swigt__p_FIX__PRICE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PRICEOFFSET[] = {  {&_swigt__p_FIX__PRICEOFFSET, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ParentMktSegmID[] = {  {&_swigt__p_FIX__ParentMktSegmID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ParticipationRate[] = {  {&_swigt__p_FIX__ParticipationRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyID[] = {  {&_swigt__p_FIX__PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyIDSource[] = {  {&_swigt__p_FIX__PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyRole[] = {  {&_swigt__p_FIX__PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartySubID[] = {  {&_swigt__p_FIX__PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartySubIDType[] = {  {&_swigt__p_FIX__PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Password[] = {  {&_swigt__p_FIX__Password, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentDate[] = {  {&_swigt__p_FIX__PaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentMethod[] = {  {&_swigt__p_FIX__PaymentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentRef[] = {  {&_swigt__p_FIX__PaymentRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentRemitterID[] = {  {&_swigt__p_FIX__PaymentRemitterID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PctAtRisk[] = {  {&_swigt__p_FIX__PctAtRisk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegDifference[] = {  {&_swigt__p_FIX__PegDifference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegLimitType[] = {  {&_swigt__p_FIX__PegLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegMoveType[] = {  {&_swigt__p_FIX__PegMoveType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegOffsetType[] = {  {&_swigt__p_FIX__PegOffsetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegOffsetValue[] = {  {&_swigt__p_FIX__PegOffsetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegPriceType[] = {  {&_swigt__p_FIX__PegPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegRoundDirection[] = {  {&_swigt__p_FIX__PegRoundDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegScope[] = {  {&_swigt__p_FIX__PegScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityDesc[] = {  {&_swigt__p_FIX__PegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityID[] = {  {&_swigt__p_FIX__PegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityIDSource[] = {  {&_swigt__p_FIX__PegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSymbol[] = {  {&_swigt__p_FIX__PegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PeggedPrice[] = {  {&_swigt__p_FIX__PeggedPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PeggedRefPrice[] = {  {&_swigt__p_FIX__PeggedRefPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Pool[] = {  {&_swigt__p_FIX__Pool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosAmt[] = {  {&_swigt__p_FIX__PosAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosAmtType[] = {  {&_swigt__p_FIX__PosAmtType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintAction[] = {  {&_swigt__p_FIX__PosMaintAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintResult[] = {  {&_swigt__p_FIX__PosMaintResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintRptID[] = {  {&_swigt__p_FIX__PosMaintRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintRptRefID[] = {  {&_swigt__p_FIX__PosMaintRptRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintStatus[] = {  {&_swigt__p_FIX__PosMaintStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosQtyStatus[] = {  {&_swigt__p_FIX__PosQtyStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqID[] = {  {&_swigt__p_FIX__PosReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqResult[] = {  {&_swigt__p_FIX__PosReqResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqStatus[] = {  {&_swigt__p_FIX__PosReqStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqType[] = {  {&_swigt__p_FIX__PosReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosTransType[] = {  {&_swigt__p_FIX__PosTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosType[] = {  {&_swigt__p_FIX__PosType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionCurrency[] = {  {&_swigt__p_FIX__PositionCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionEffect[] = {  {&_swigt__p_FIX__PositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionLimit[] = {  {&_swigt__p_FIX__PositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PossDupFlag[] = {  {&_swigt__p_FIX__PossDupFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PossResend[] = {  {&_swigt__p_FIX__PossResend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreTradeAnonymity[] = {  {&_swigt__p_FIX__PreTradeAnonymity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreallocMethod[] = {  {&_swigt__p_FIX__PreallocMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PrevClosePx[] = {  {&_swigt__p_FIX__PrevClosePx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreviouslyReported[] = {  {&_swigt__p_FIX__PreviouslyReported, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Price[] = {  {&_swigt__p_FIX__Price, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Price2[] = {  {&_swigt__p_FIX__Price2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceDelta[] = {  {&_swigt__p_FIX__PriceDelta, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceImprovement[] = {  {&_swigt__p_FIX__PriceImprovement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceLimitType[] = {  {&_swigt__p_FIX__PriceLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceProtectionScope[] = {  {&_swigt__p_FIX__PriceProtectionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceQuoteMethod[] = {  {&_swigt__p_FIX__PriceQuoteMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceType[] = {  {&_swigt__p_FIX__PriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceUnitOfMeasure[] = {  {&_swigt__p_FIX__PriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__PriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorSettlPrice[] = {  {&_swigt__p_FIX__PriorSettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorSpreadIndicator[] = {  {&_swigt__p_FIX__PriorSpreadIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorityIndicator[] = {  {&_swigt__p_FIX__PriorityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PrivateQuote[] = {  {&_swigt__p_FIX__PrivateQuote, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProcessCode[] = {  {&_swigt__p_FIX__ProcessCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Product[] = {  {&_swigt__p_FIX__Product, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProductComplex[] = {  {&_swigt__p_FIX__ProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProgPeriodInterval[] = {  {&_swigt__p_FIX__ProgPeriodInterval, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProgRptReqs[] = {  {&_swigt__p_FIX__ProgRptReqs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PublishTrdIndicator[] = {  {&_swigt__p_FIX__PublishTrdIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PutOrCall[] = {  {&_swigt__p_FIX__PutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QTY[] = {  {&_swigt__p_FIX__QTY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QtyType[] = {  {&_swigt__p_FIX__QtyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Quantity[] = {  {&_swigt__p_FIX__Quantity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuantityDate[] = {  {&_swigt__p_FIX__QuantityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuantityType[] = {  {&_swigt__p_FIX__QuantityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteAckStatus[] = {  {&_swigt__p_FIX__QuoteAckStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteCancelType[] = {  {&_swigt__p_FIX__QuoteCancelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteCondition[] = {  {&_swigt__p_FIX__QuoteCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryID[] = {  {&_swigt__p_FIX__QuoteEntryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryRejectReason[] = {  {&_swigt__p_FIX__QuoteEntryRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryStatus[] = {  {&_swigt__p_FIX__QuoteEntryStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteID[] = {  {&_swigt__p_FIX__QuoteID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteMsgID[] = {  {&_swigt__p_FIX__QuoteMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuotePriceType[] = {  {&_swigt__p_FIX__QuotePriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteQualifier[] = {  {&_swigt__p_FIX__QuoteQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRejectReason[] = {  {&_swigt__p_FIX__QuoteRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteReqID[] = {  {&_swigt__p_FIX__QuoteReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRequestRejectReason[] = {  {&_swigt__p_FIX__QuoteRequestRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRequestType[] = {  {&_swigt__p_FIX__QuoteRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRespID[] = {  {&_swigt__p_FIX__QuoteRespID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRespType[] = {  {&_swigt__p_FIX__QuoteRespType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteResponseLevel[] = {  {&_swigt__p_FIX__QuoteResponseLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteSetID[] = {  {&_swigt__p_FIX__QuoteSetID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteSetValidUntilTime[] = {  {&_swigt__p_FIX__QuoteSetValidUntilTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteStatus[] = {  {&_swigt__p_FIX__QuoteStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteStatusReqID[] = {  {&_swigt__p_FIX__QuoteStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteType[] = {  {&_swigt__p_FIX__QuoteType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RFQReqID[] = {  {&_swigt__p_FIX__RFQReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RateSource[] = {  {&_swigt__p_FIX__RateSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RateSourceType[] = {  {&_swigt__p_FIX__RateSourceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RatioQty[] = {  {&_swigt__p_FIX__RatioQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RawData[] = {  {&_swigt__p_FIX__RawData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RawDataLength[] = {  {&_swigt__p_FIX__RawDataLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReceivedDeptID[] = {  {&_swigt__p_FIX__ReceivedDeptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RedemptionDate[] = {  {&_swigt__p_FIX__RedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefAllocID[] = {  {&_swigt__p_FIX__RefAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplExtID[] = {  {&_swigt__p_FIX__RefApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplID[] = {  {&_swigt__p_FIX__RefApplID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplLastSeqNum[] = {  {&_swigt__p_FIX__RefApplLastSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplReqID[] = {  {&_swigt__p_FIX__RefApplReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplVerID[] = {  {&_swigt__p_FIX__RefApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefCompID[] = {  {&_swigt__p_FIX__RefCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefCstmApplVerID[] = {  {&_swigt__p_FIX__RefCstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefMsgType[] = {  {&_swigt__p_FIX__RefMsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrdIDReason[] = {  {&_swigt__p_FIX__RefOrdIDReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrderID[] = {  {&_swigt__p_FIX__RefOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrderIDSource[] = {  {&_swigt__p_FIX__RefOrderIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefSeqNum[] = {  {&_swigt__p_FIX__RefSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefSubID[] = {  {&_swigt__p_FIX__RefSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefTagID[] = {  {&_swigt__p_FIX__RefTagID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReferencePage[] = {  {&_swigt__p_FIX__ReferencePage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefreshIndicator[] = {  {&_swigt__p_FIX__RefreshIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefreshQty[] = {  {&_swigt__p_FIX__RefreshQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistAcctType[] = {  {&_swigt__p_FIX__RegistAcctType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistDetls[] = {  {&_swigt__p_FIX__RegistDetls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistDtls[] = {  {&_swigt__p_FIX__RegistDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistEmail[] = {  {&_swigt__p_FIX__RegistEmail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistID[] = {  {&_swigt__p_FIX__RegistID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRefID[] = {  {&_swigt__p_FIX__RegistRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRejReasonCode[] = {  {&_swigt__p_FIX__RegistRejReasonCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRejReasonText[] = {  {&_swigt__p_FIX__RegistRejReasonText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistStatus[] = {  {&_swigt__p_FIX__RegistStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistTransType[] = {  {&_swigt__p_FIX__RegistTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RejectLogon[] = {  {&_swigt__p_FIX__RejectLogon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RejectText[] = {  {&_swigt__p_FIX__RejectText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelSymTransactTime[] = {  {&_swigt__p_FIX__RelSymTransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatdSym[] = {  {&_swigt__p_FIX__RelatdSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepeatedTag[] = {  {&_swigt__p_FIX__RepeatedTag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepeatingGroupCountMismatch[] = {  {&_swigt__p_FIX__RepeatingGroupCountMismatch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepoCollateralSecurityType[] = {  {&_swigt__p_FIX__RepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportToExch[] = {  {&_swigt__p_FIX__ReportToExch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportedPx[] = {  {&_swigt__p_FIX__ReportedPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportedPxDiff[] = {  {&_swigt__p_FIX__ReportedPxDiff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepurchaseRate[] = {  {&_swigt__p_FIX__RepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepurchaseTerm[] = {  {&_swigt__p_FIX__RepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RequiredTagMissing[] = {  {&_swigt__p_FIX__RequiredTagMissing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResetSeqNumFlag[] = {  {&_swigt__p_FIX__ResetSeqNumFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RespondentType[] = {  {&_swigt__p_FIX__RespondentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResponseDestination[] = {  {&_swigt__p_FIX__ResponseDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResponseTransportType[] = {  {&_swigt__p_FIX__ResponseTransportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RestructuringType[] = {  {&_swigt__p_FIX__RestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReversalIndicator[] = {  {&_swigt__p_FIX__ReversalIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskFreeRate[] = {  {&_swigt__p_FIX__RiskFreeRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RndPx[] = {  {&_swigt__p_FIX__RndPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyID[] = {  {&_swigt__p_FIX__RootPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyIDSource[] = {  {&_swigt__p_FIX__RootPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyRole[] = {  {&_swigt__p_FIX__RootPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartySubID[] = {  {&_swigt__p_FIX__RootPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartySubIDType[] = {  {&_swigt__p_FIX__RootPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundLot[] = {  {&_swigt__p_FIX__RoundLot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundingDirection[] = {  {&_swigt__p_FIX__RoundingDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundingModulus[] = {  {&_swigt__p_FIX__RoundingModulus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoutingID[] = {  {&_swigt__p_FIX__RoutingID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoutingType[] = {  {&_swigt__p_FIX__RoutingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RptSeq[] = {  {&_swigt__p_FIX__RptSeq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RptSys[] = {  {&_swigt__p_FIX__RptSys, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Rule80A[] = {  {&_swigt__p_FIX__Rule80A, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RuntimeError[] = {  {&_swigt__p_FIX__RuntimeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SEQNUM[] = {  {&_swigt__p_FIX__SEQNUM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__STRING[] = {  {&_swigt__p_FIX__STRING, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Scope[] = {  {&_swigt__p_FIX__Scope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ScreenLog[] = {  {&_swigt__p_FIX__ScreenLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ScreenLogFactory[] = {  {&_swigt__p_FIX__ScreenLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryAllocID[] = {  {&_swigt__p_FIX__SecondaryAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryClOrdID[] = {  {&_swigt__p_FIX__SecondaryClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryDisplayQty[] = {  {&_swigt__p_FIX__SecondaryDisplayQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryExecID[] = {  {&_swigt__p_FIX__SecondaryExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryFirmTradeID[] = {  {&_swigt__p_FIX__SecondaryFirmTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryHighLimitPrice[] = {  {&_swigt__p_FIX__SecondaryHighLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryIndividualAllocID[] = {  {&_swigt__p_FIX__SecondaryIndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryLowLimitPrice[] = {  {&_swigt__p_FIX__SecondaryLowLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryOrderID[] = {  {&_swigt__p_FIX__SecondaryOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryPriceLimitType[] = {  {&_swigt__p_FIX__SecondaryPriceLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeID[] = {  {&_swigt__p_FIX__SecondaryTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeReportID[] = {  {&_swigt__p_FIX__SecondaryTradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeReportRefID[] = {  {&_swigt__p_FIX__SecondaryTradeReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradingReferencePrice[] = {  {&_swigt__p_FIX__SecondaryTradingReferencePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTrdType[] = {  {&_swigt__p_FIX__SecondaryTrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecureData[] = {  {&_swigt__p_FIX__SecureData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecureDataLen[] = {  {&_swigt__p_FIX__SecureDataLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityAltID[] = {  {&_swigt__p_FIX__SecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityAltIDSource[] = {  {&_swigt__p_FIX__SecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityDesc[] = {  {&_swigt__p_FIX__SecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityExchange[] = {  {&_swigt__p_FIX__SecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityGroup[] = {  {&_swigt__p_FIX__SecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityID[] = {  {&_swigt__p_FIX__SecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityIDSource[] = {  {&_swigt__p_FIX__SecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListDesc[] = {  {&_swigt__p_FIX__SecurityListDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListID[] = {  {&_swigt__p_FIX__SecurityListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListRefID[] = {  {&_swigt__p_FIX__SecurityListRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListRequestType[] = {  {&_swigt__p_FIX__SecurityListRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListType[] = {  {&_swigt__p_FIX__SecurityListType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListTypeSource[] = {  {&_swigt__p_FIX__SecurityListTypeSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityReportID[] = {  {&_swigt__p_FIX__SecurityReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityReqID[] = {  {&_swigt__p_FIX__SecurityReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityRequestResult[] = {  {&_swigt__p_FIX__SecurityRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityRequestType[] = {  {&_swigt__p_FIX__SecurityRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityResponseID[] = {  {&_swigt__p_FIX__SecurityResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityResponseType[] = {  {&_swigt__p_FIX__SecurityResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentAcctName[] = {  {&_swigt__p_FIX__SecuritySettlAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentAcctNum[] = {  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentCode[] = {  {&_swigt__p_FIX__SecuritySettlAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentContactName[] = {  {&_swigt__p_FIX__SecuritySettlAgentContactName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentContactPhone[] = {  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentName[] = {  {&_swigt__p_FIX__SecuritySettlAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityStatus[] = {  {&_swigt__p_FIX__SecurityStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityStatusReqID[] = {  {&_swigt__p_FIX__SecurityStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySubType[] = {  {&_swigt__p_FIX__SecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityTradingEvent[] = {  {&_swigt__p_FIX__SecurityTradingEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityTradingStatus[] = {  {&_swigt__p_FIX__SecurityTradingStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityType[] = {  {&_swigt__p_FIX__SecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityUpdateAction[] = {  {&_swigt__p_FIX__SecurityUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXML[] = {  {&_swigt__p_FIX__SecurityXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXMLLen[] = {  {&_swigt__p_FIX__SecurityXMLLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXMLSchema[] = {  {&_swigt__p_FIX__SecurityXMLSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SellVolume[] = {  {&_swigt__p_FIX__SellVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SellerDays[] = {  {&_swigt__p_FIX__SellerDays, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderCompID[] = {  {&_swigt__p_FIX__SenderCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderLocationID[] = {  {&_swigt__p_FIX__SenderLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderSubID[] = {  {&_swigt__p_FIX__SenderSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SendingDate[] = {  {&_swigt__p_FIX__SendingDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SendingTime[] = {  {&_swigt__p_FIX__SendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Seniority[] = {  {&_swigt__p_FIX__Seniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Session[] = {  {&_swigt__p_FIX__Session, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionID[] = {  {&_swigt__p_FIX__SessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionNotFound[] = {  {&_swigt__p_FIX__SessionNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionRejectReason[] = {  {&_swigt__p_FIX__SessionRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionSettings[] = {  {&_swigt__p_FIX__SessionSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionStatus[] = {  {&_swigt__p_FIX__SessionStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlBrkrCode[] = {  {&_swigt__p_FIX__SettlBrkrCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrAmt[] = {  {&_swigt__p_FIX__SettlCurrAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrBidFxRate[] = {  {&_swigt__p_FIX__SettlCurrBidFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrFxRate[] = {  {&_swigt__p_FIX__SettlCurrFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrFxRateCalc[] = {  {&_swigt__p_FIX__SettlCurrFxRateCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrOfferFxRate[] = {  {&_swigt__p_FIX__SettlCurrOfferFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrency[] = {  {&_swigt__p_FIX__SettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDate[] = {  {&_swigt__p_FIX__SettlDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDate2[] = {  {&_swigt__p_FIX__SettlDate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDeliveryType[] = {  {&_swigt__p_FIX__SettlDeliveryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDepositoryCode[] = {  {&_swigt__p_FIX__SettlDepositoryCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstCode[] = {  {&_swigt__p_FIX__SettlInstCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstID[] = {  {&_swigt__p_FIX__SettlInstID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstMode[] = {  {&_swigt__p_FIX__SettlInstMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstMsgID[] = {  {&_swigt__p_FIX__SettlInstMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstRefID[] = {  {&_swigt__p_FIX__SettlInstRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstReqID[] = {  {&_swigt__p_FIX__SettlInstReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstReqRejCode[] = {  {&_swigt__p_FIX__SettlInstReqRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstSource[] = {  {&_swigt__p_FIX__SettlInstSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstTransType[] = {  {&_swigt__p_FIX__SettlInstTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlLocation[] = {  {&_swigt__p_FIX__SettlLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlMethod[] = {  {&_swigt__p_FIX__SettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligID[] = {  {&_swigt__p_FIX__SettlObligID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligMode[] = {  {&_swigt__p_FIX__SettlObligMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligMsgID[] = {  {&_swigt__p_FIX__SettlObligMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligRefID[] = {  {&_swigt__p_FIX__SettlObligRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligSource[] = {  {&_swigt__p_FIX__SettlObligSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligTransType[] = {  {&_swigt__p_FIX__SettlObligTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyID[] = {  {&_swigt__p_FIX__SettlPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyIDSource[] = {  {&_swigt__p_FIX__SettlPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyRole[] = {  {&_swigt__p_FIX__SettlPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartySubID[] = {  {&_swigt__p_FIX__SettlPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartySubIDType[] = {  {&_swigt__p_FIX__SettlPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPrice[] = {  {&_swigt__p_FIX__SettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPriceType[] = {  {&_swigt__p_FIX__SettlPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlSessID[] = {  {&_swigt__p_FIX__SettlSessID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlSessSubID[] = {  {&_swigt__p_FIX__SettlSessSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlType[] = {  {&_swigt__p_FIX__SettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettleOnOpenFlag[] = {  {&_swigt__p_FIX__SettleOnOpenFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlementCycleNo[] = {  {&_swigt__p_FIX__SettlementCycleNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlmntTyp[] = {  {&_swigt__p_FIX__SettlmntTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SharedCommission[] = {  {&_swigt__p_FIX__SharedCommission, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Shares[] = {  {&_swigt__p_FIX__Shares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ShortQty[] = {  {&_swigt__p_FIX__ShortQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ShortSaleReason[] = {  {&_swigt__p_FIX__ShortSaleReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Side[] = {  {&_swigt__p_FIX__Side, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideComplianceID[] = {  {&_swigt__p_FIX__SideComplianceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideCurrency[] = {  {&_swigt__p_FIX__SideCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideExecID[] = {  {&_swigt__p_FIX__SideExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideFillStationCd[] = {  {&_swigt__p_FIX__SideFillStationCd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideGrossTradeAmt[] = {  {&_swigt__p_FIX__SideGrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideLastQty[] = {  {&_swigt__p_FIX__SideLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideLiquidityInd[] = {  {&_swigt__p_FIX__SideLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideMultiLegReportingType[] = {  {&_swigt__p_FIX__SideMultiLegReportingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideQty[] = {  {&_swigt__p_FIX__SideQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideReasonCd[] = {  {&_swigt__p_FIX__SideReasonCd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideSettlCurrency[] = {  {&_swigt__p_FIX__SideSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTimeInForce[] = {  {&_swigt__p_FIX__SideTimeInForce, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTradeReportID[] = {  {&_swigt__p_FIX__SideTradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestamp[] = {  {&_swigt__p_FIX__SideTrdRegTimestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestampSrc[] = {  {&_swigt__p_FIX__SideTrdRegTimestampSrc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestampType[] = {  {&_swigt__p_FIX__SideTrdRegTimestampType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdSubTyp[] = {  {&_swigt__p_FIX__SideTrdSubTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValue1[] = {  {&_swigt__p_FIX__SideValue1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValue2[] = {  {&_swigt__p_FIX__SideValue2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValueInd[] = {  {&_swigt__p_FIX__SideValueInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Signature[] = {  {&_swigt__p_FIX__Signature, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SignatureLength[] = {  {&_swigt__p_FIX__SignatureLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketAcceptor[] = {  {&_swigt__p_FIX__SocketAcceptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketCloseFailed[] = {  {&_swigt__p_FIX__SocketCloseFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketException[] = {  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketException, 0, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__SocketException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketInitiator[] = {  {&_swigt__p_FIX__SocketInitiator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketRecvFailed[] = {  {&_swigt__p_FIX__SocketRecvFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketSendFailed[] = {  {&_swigt__p_FIX__SocketSendFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SolicitedFlag[] = {  {&_swigt__p_FIX__SolicitedFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Spread[] = {  {&_swigt__p_FIX__Spread, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SpreadToBenchmark[] = {  {&_swigt__p_FIX__SpreadToBenchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbID[] = {  {&_swigt__p_FIX__StandInstDbID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbName[] = {  {&_swigt__p_FIX__StandInstDbName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbType[] = {  {&_swigt__p_FIX__StandInstDbType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartCash[] = {  {&_swigt__p_FIX__StartCash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartDate[] = {  {&_swigt__p_FIX__StartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartMaturityMonthYear[] = {  {&_swigt__p_FIX__StartMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartStrikePxRange[] = {  {&_swigt__p_FIX__StartStrikePxRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartTickPriceRange[] = {  {&_swigt__p_FIX__StartTickPriceRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__StateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatsType[] = {  {&_swigt__p_FIX__StatsType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatusText[] = {  {&_swigt__p_FIX__StatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatusValue[] = {  {&_swigt__p_FIX__StatusValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StipulationType[] = {  {&_swigt__p_FIX__StipulationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StipulationValue[] = {  {&_swigt__p_FIX__StipulationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StopPx[] = {  {&_swigt__p_FIX__StopPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterName[] = {  {&_swigt__p_FIX__StrategyParameterName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterType[] = {  {&_swigt__p_FIX__StrategyParameterType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterValue[] = {  {&_swigt__p_FIX__StrategyParameterValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnAckType[] = {  {&_swigt__p_FIX__StreamAsgnAckType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnRejReason[] = {  {&_swigt__p_FIX__StreamAsgnRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnReqID[] = {  {&_swigt__p_FIX__StreamAsgnReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnReqType[] = {  {&_swigt__p_FIX__StreamAsgnReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnRptID[] = {  {&_swigt__p_FIX__StreamAsgnRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnType[] = {  {&_swigt__p_FIX__StreamAsgnType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeCurrency[] = {  {&_swigt__p_FIX__StrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeExerciseStyle[] = {  {&_swigt__p_FIX__StrikeExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeIncrement[] = {  {&_swigt__p_FIX__StrikeIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeMultiplier[] = {  {&_swigt__p_FIX__StrikeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePrice[] = {  {&_swigt__p_FIX__StrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceBoundaryMethod[] = {  {&_swigt__p_FIX__StrikePriceBoundaryMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceBoundaryPrecision[] = {  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceDeterminationMethod[] = {  {&_swigt__p_FIX__StrikePriceDeterminationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeRuleID[] = {  {&_swigt__p_FIX__StrikeRuleID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeTime[] = {  {&_swigt__p_FIX__StrikeTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeValue[] = {  {&_swigt__p_FIX__StrikeValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StringField[] = {  {&_swigt__p_FIX__DeliveryDate, _p_FIX__DeliveryDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RFQReqID, _p_FIX__RFQReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedText, _p_FIX__EncodedTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BidID, _p_FIX__BidIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteCondition, _p_FIX__QuoteConditionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExchangeRule, _p_FIX__ExchangeRuleTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate2, _p_FIX__FutSettDate2To_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollAsgnID, _p_FIX__CollAsgnIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NetworkRequestID, _p_FIX__NetworkRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClientBidID, _p_FIX__ClientBidIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ReferencePage, _p_FIX__ReferencePageTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Text, _p_FIX__TextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDFeedType, _p_FIX__MDFeedTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UserStatusText, _p_FIX__UserStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StatusText, _p_FIX__StatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListStatusText, _p_FIX__ListStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedListStatusText, _p_FIX__EncodedListStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIid, _p_FIX__IOIidTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDate, _p_FIX__SettlDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSettlDate, _p_FIX__LegSettlDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskType, _p_FIX__DeskTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasure, _p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnitOfMeasure, _p_FIX__UnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasure, _p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasure, _p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasure, _p_FIX__LegUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, _p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, _p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TransferReason, _p_FIX__TransferReasonTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityDesc, _p_FIX__DerivativeSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityDesc, _p_FIX__TriggerSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityDesc, _p_FIX__PegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, _p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityDesc, _p_FIX__SecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, _p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDesc, _p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Username, _p_FIX__UsernameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistRejReasonText, _p_FIX__RegistRejReasonTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlBrkrCode, _p_FIX__SettlBrkrCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplID, _p_FIX__RefApplIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplID, _p_FIX__ApplIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Pool, _p_FIX__PoolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampSrc, _p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SendingDate, _p_FIX__SendingDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested4PartyID, _p_FIX__Nested4PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyID, _p_FIX__PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RootPartyID, _p_FIX__RootPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollInquiryID, _p_FIX__CollInquiryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlSessID, _p_FIX__SettlSessIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketSegmentDesc, _p_FIX__MarketSegmentDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementDesc, _p_FIX__AgreementDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteReqID, _p_FIX__QuoteReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FillExecID, _p_FIX__FillExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideExecID, _p_FIX__SideExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentName, _p_FIX__CashSettlAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentName, _p_FIX__CashDistribAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentName, _p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MailingDtls, _p_FIX__MailingDtlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityAltID, _p_FIX__LegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, _p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedAllocText, _p_FIX__EncodedAllocTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocText, _p_FIX__AllocTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClientID, _p_FIX__ClientIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetSubID, _p_FIX__TargetSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatdSym, _p_FIX__RelatdSymTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactName, _p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctName, _p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctName, _p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctName, _p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactName, _p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplVerID, _p_FIX__ApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefCstmApplVerID, _p_FIX__RefCstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DefaultApplVerID, _p_FIX__DefaultApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CstmApplVerID, _p_FIX__CstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplVerID, _p_FIX__RefApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DefaultCstmApplVerID, _p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Country, _p_FIX__CountryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardHolderName, _p_FIX__CardHolderNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrategyParameterName, _p_FIX__StrategyParameterNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderLocationID, _p_FIX__SenderLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LocationID, _p_FIX__LocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetLocationID, _p_FIX__TargetLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfLocationID, _p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToLocationID, _p_FIX__DeliverToLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeInputDevice, _p_FIX__TradeInputDeviceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderInputDevice, _p_FIX__OrderInputDeviceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessCurr, _p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocSettlCurrency, _p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CommCurrency, _p_FIX__CommCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikeCurrency, _p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeCurrency, _p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementCurrency, _p_FIX__AgreementCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingCurrency, _p_FIX__TradingCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Currency, _p_FIX__CurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrikeCurrency, _p_FIX__StrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlCurrency, _p_FIX__SettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSettlCurrency, _p_FIX__LegSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCurrency, _p_FIX__LegCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideCurrency, _p_FIX__SideCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveCurrency, _p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, _p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideSettlCurrency, _p_FIX__SideSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingFeeIndicator, _p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocClearingFeeIndicator, _p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocCustomerCapacity, _p_FIX__AllocCustomerCapacityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDReqID, _p_FIX__MDReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Signature, _p_FIX__SignatureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StandInstDbID, _p_FIX__StandInstDbIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstMsgID, _p_FIX__SettlInstMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BrokerOfCredit, _p_FIX__BrokerOfCreditTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DatedDate, _p_FIX__DatedDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CrossID, _p_FIX__CrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollAsgnRefID, _p_FIX__CollAsgnRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityReqID, _p_FIX__SecurityReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OpenCloseSettlFlag, _p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NotAffectedOrderID, _p_FIX__NotAffectedOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderID, _p_FIX__OrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedOrderID, _p_FIX__AffectedOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MailingInst, _p_FIX__MailingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CustOrderHandlingInst, _p_FIX__CustOrderHandlingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlSessSubID, _p_FIX__SettlSessSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurvePoint, _p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurvePoint, _p_FIX__BenchmarkCurvePointTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraTrader, _p_FIX__ContraTraderTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentRef, _p_FIX__PaymentRefTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionID, _p_FIX__TradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionID, _p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionID, _p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Scope, _p_FIX__ScopeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqID, _p_FIX__StreamAsgnReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstID, _p_FIX__SettlInstIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecRefID, _p_FIX__ExecRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardExpDate, _p_FIX__CardExpDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExDate, _p_FIX__ExDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteSetID, _p_FIX__QuoteSetIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctNumber, _p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardNumber, _p_FIX__CardNumberTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplResponseID, _p_FIX__ApplResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LastMkt, _p_FIX__LastMktTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDMkt, _p_FIX__MDMktTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntrySeller, _p_FIX__MDEntrySellerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RedemptionDate, _p_FIX__RedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeOriginationDate, _p_FIX__TradeOriginationDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRedemptionDate, _p_FIX__LegRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRedemptionDate, _p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionDate, _p_FIX__YieldRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeID, _p_FIX__TradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FirmTradeID, _p_FIX__FirmTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeID, _p_FIX__SecondaryTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigTradeID, _p_FIX__OrigTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigSecondaryTradeID, _p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InvestorCountryOfResidence, _p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CreditRating, _p_FIX__CreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCreditRating, _p_FIX__LegCreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCreditRating, _p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmRefID, _p_FIX__ConfirmRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryBuyer, _p_FIX__MDEntryBuyerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderSubID, _p_FIX__SenderSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCashType, _p_FIX__UnderlyingCashTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampOrigin, _p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TrdMatchID, _p_FIX__TrdMatchIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmReqID, _p_FIX__ConfirmReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityRuleID, _p_FIX__MaturityRuleIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrikeRuleID, _p_FIX__StrikeRuleIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityID, _p_FIX__TriggerSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityID, _p_FIX__LegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityID, _p_FIX__SecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityID, _p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityID, _p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefCompID, _p_FIX__RefCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__HopCompID, _p_FIX__HopCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfCompID, _p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactPhone, _p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, _p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToCompID, _p_FIX__DeliverToCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmID, _p_FIX__ConfirmIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EndDate, _p_FIX__EndDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, _p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCountryOfIssue, _p_FIX__LegCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, _p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCountryOfIssue, _p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LocaleOfIssue, _p_FIX__LocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StateOrProvinceOfIssue, _p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CountryOfIssue, _p_FIX__CountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeLocaleOfIssue, _p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, _p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldType, _p_FIX__YieldTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSymbol, _p_FIX__TriggerSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Symbol, _p_FIX__SymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbol, _p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSymbol, _p_FIX__PegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AltMDSourceID, _p_FIX__AltMDSourceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrategyParameterValue, _p_FIX__StrategyParameterValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlMethod, _p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, _p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ValuationMethod, _p_FIX__ValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FuturesValuationMethod, _p_FIX__FuturesValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeValuationMethod, _p_FIX__DerivativeValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativePriceQuoteMethod, _p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PriceQuoteMethod, _p_FIX__PriceQuoteMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__WaveNo, _p_FIX__WaveNoTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDtls, _p_FIX__RegistDtlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligMsgID, _p_FIX__SettlObligMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewPassword, _p_FIX__NewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedPassword, _p_FIX__EncryptedPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StringField, 0, 0, 0},  {&_swigt__p_FIX__MessageEncoding, _p_FIX__MessageEncodingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIQty, _p_FIX__IOIQtyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIOIQty, _p_FIX__LegIOIQtyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefMsgType, _p_FIX__RefMsgTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MsgType, _p_FIX__MsgTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDesc, _p_FIX__EncodedMktSegmDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettleOnOpenFlag, _p_FIX__SettleOnOpenFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, _p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXML, _p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityXML, _p_FIX__SecurityXMLTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StartDate, _p_FIX__StartDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardStartDate, _p_FIX__CardStartDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefSubID, _p_FIX__RefSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSubID, _p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingBusinessDate, _p_FIX__ClearingBusinessDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MatchAlgorithm, _p_FIX__MatchAlgorithmTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribPayRef, _p_FIX__CashDistribPayRefTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecInst, _p_FIX__ExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvRefID, _p_FIX__AdvRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__URLLink, _p_FIX__URLLinkTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideReasonCd, _p_FIX__SideReasonCdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStipType, _p_FIX__UnderlyingStipTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentRemitterID, _p_FIX__PaymentRemitterIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CFICode, _p_FIX__CFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegCFICode, _p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplReportID, _p_FIX__ApplReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideTradeReportID, _p_FIX__SideTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocReportID, _p_FIX__AllocReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportID, _p_FIX__TradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegReportID, _p_FIX__LegReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketReportID, _p_FIX__MarketReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MassActionReportID, _p_FIX__MassActionReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RoutingID, _p_FIX__RoutingIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExchangeSpecialInstructions, _p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderRestrictions, _p_FIX__OrderRestrictionsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TimeUnit, _p_FIX__TimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegTimeUnit, _p_FIX__LegTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeTimeUnit, _p_FIX__DerivativeTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTimeUnit, _p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecBroker, _p_FIX__ExecBrokerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraBroker, _p_FIX__ContraBrokerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewsID, _p_FIX__NewsIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ParentMktSegmID, _p_FIX__ParentMktSegmIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Subject, _p_FIX__SubjectTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EventText, _p_FIX__EventTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionDesc, _p_FIX__TradingSessionDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocID, _p_FIX__AllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIndividualAllocID, _p_FIX__LegIndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocID, _p_FIX__LegAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryIndividualAllocID, _p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefAllocID, _p_FIX__RefAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IndividualAllocID, _p_FIX__IndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryAllocID, _p_FIX__SecondaryAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardIssNum, _p_FIX__CardIssNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityType, _p_FIX__SecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityType, _p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ReceivedDeptID, _p_FIX__ReceivedDeptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteMsgID, _p_FIX__QuoteMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCPProgram, _p_FIX__UnderlyingCPProgramTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToSubID, _p_FIX__DeliverToSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RejectText, _p_FIX__RejectTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIShares, _p_FIX__IOISharesTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IssueDate, _p_FIX__IssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIssueDate, _p_FIX__LegIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteID, _p_FIX__QuoteIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListDesc, _p_FIX__SecurityListDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClOrdLinkID, _p_FIX__ClOrdLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDesc, _p_FIX__EncodedSecurityListDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TierCode, _p_FIX__TierCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedHeadline, _p_FIX__EncodedHeadlineTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Headline, _p_FIX__HeadlineTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistEmail, _p_FIX__RegistEmailTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeInputSource, _p_FIX__TradeInputSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityIDSource, _p_FIX__LegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityIDSource, _p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityIDSource, _p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IDSource, _p_FIX__IDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContAmtCurr, _p_FIX__ContAmtCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, _p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltIDSource, _p_FIX__SecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIDSource, _p_FIX__UnderlyingIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityAltIDSource, _p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityIDSource, _p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityIDSource, _p_FIX__PegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InputSource, _p_FIX__InputSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityIDSource, _p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocAcctIDSource, _p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, _p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, _p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityDay, _p_FIX__MaturityDayTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosType, _p_FIX__PosTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDay, _p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListName, _p_FIX__ListNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingFirm, _p_FIX__ClearingFirmTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldCalcDate, _p_FIX__YieldCalcDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OpenCloseSettleFlag, _p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListRefID, _p_FIX__SecurityListRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstRefID, _p_FIX__SettlInstRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BusinessRejectRefID, _p_FIX__BusinessRejectRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistRefID, _p_FIX__RegistRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosMaintRptRefID, _p_FIX__PosMaintRptRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportRefID, _p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistAcctType, _p_FIX__RegistAcctTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideFillStationCd, _p_FIX__SideFillStationCdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested2PartySubID, _p_FIX__Nested2PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartySubID, _p_FIX__NestedPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteEntryID, _p_FIX__QuoteEntryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RootPartySubID, _p_FIX__RootPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryID, _p_FIX__MDEntryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartySubID, _p_FIX__PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartySubID, _p_FIX__SettlPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, _p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested4PartySubID, _p_FIX__Nested4PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartySubID, _p_FIX__Nested3PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, _p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubID, _p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__XmlData, _p_FIX__XmlDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDStreamID, _p_FIX__MDStreamIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstReqID, _p_FIX__SettlInstReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketReqID, _p_FIX__MarketReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollRptID, _p_FIX__CollRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TestReqID, _p_FIX__TestReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIRefID, _p_FIX__IOIRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, _p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctNum, _p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LanguageCode, _p_FIX__LanguageCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, _p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionSubID, _p_FIX__TradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionSubID, _p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocAccount, _p_FIX__AllocAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocAccount, _p_FIX__LegAllocAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingAccount, _p_FIX__ClearingAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Account, _p_FIX__AccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Issuer, _p_FIX__IssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuer, _p_FIX__EncodedLegIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssuer, _p_FIX__UnderlyingIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeIssuer, _p_FIX__DerivativeIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuer, _p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIssuer, _p_FIX__LegIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BidDescriptor, _p_FIX__BidDescriptorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, _p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecuritySubType, _p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TimeBracket, _p_FIX__TimeBracketTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosAmtType, _p_FIX__PosAmtTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvTransType, _p_FIX__AdvTransTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDepositoryCode, _p_FIX__SettlDepositoryCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CPRegType, _p_FIX__CPRegTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegPool, _p_FIX__LegPoolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCPRegType, _p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RawData, _p_FIX__RawDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketID, _p_FIX__MarketIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDate2, _p_FIX__SettlDate2To_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskID, _p_FIX__DeskIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewsRefID, _p_FIX__NewsRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribCurr, _p_FIX__CashDistribCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketSegmentID, _p_FIX__MarketSegmentIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStipulationValue, _p_FIX__LegStipulationValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementID, _p_FIX__AgreementIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StipulationValue, _p_FIX__StipulationValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityDate, _p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuantityDate, _p_FIX__QuantityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityDate, _p_FIX__LegMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDate, _p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MassStatusReqID, _p_FIX__MassStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradSesReqID, _p_FIX__TradSesReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosReqID, _p_FIX__PosReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityStatusReqID, _p_FIX__SecurityStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StandInstDbName, _p_FIX__StandInstDbNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityTime, _p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityTime, _p_FIX__MaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Designation, _p_FIX__DesignationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExDestination, _p_FIX__ExDestinationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ResponseDestination, _p_FIX__ResponseDestinationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardIssNo, _p_FIX__CardIssNoTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveName, _p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveName, _p_FIX__BenchmarkCurveNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEventDate, _p_FIX__DerivativeEventDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CouponPaymentDate, _p_FIX__CouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, _p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentDate, _p_FIX__PaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EventDate, _p_FIX__EventDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementDate, _p_FIX__AgreementDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCouponPaymentDate, _p_FIX__LegCouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MatchType, _p_FIX__MatchTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CorporateAction, _p_FIX__CorporateActionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EmailThreadID, _p_FIX__EmailThreadIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlLocation, _p_FIX__SettlLocationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MiscFeeCurr, _p_FIX__MiscFeeCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIID, _p_FIX__IOIIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlType, _p_FIX__SettlTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvId, _p_FIX__AdvIdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraLegRefID, _p_FIX__ContraLegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeLegRefID, _p_FIX__TradeLegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRefID, _p_FIX__LegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligRefID, _p_FIX__SettlObligRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContractSettlMonth, _p_FIX__ContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegContractSettlMonth, _p_FIX__LegContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BookingRefID, _p_FIX__BookingRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeContractSettlMonth, _p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecureData, _p_FIX__SecureDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityExchange, _p_FIX__LegSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityExchange, _p_FIX__SecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, _p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityExchange, _p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRestructuringType, _p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DateOfBirth, _p_FIX__DateOfBirthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExpireDate, _p_FIX__ExpireDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BasisFeatureDate, _p_FIX__BasisFeatureDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollRespID, _p_FIX__CollRespIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RptSys, _p_FIX__RptSysTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteRespID, _p_FIX__QuoteRespIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ProductComplex, _p_FIX__ProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeProductComplex, _p_FIX__DerivativeProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistID, _p_FIX__RegistIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MiscFeeType, _p_FIX__MiscFeeTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, _p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EndMaturityMonthYear, _p_FIX__EndMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigPosReqRefID, _p_FIX__OrigPosReqRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosMaintRptID, _p_FIX__PosMaintRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContIntRptID, _p_FIX__ContIntRptIDTo_p_FIX__StringField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Subject[] = {  {&_swigt__p_FIX__Subject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SubscriptionRequestType[] = {  {&_swigt__p_FIX__SubscriptionRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SwapPoints[] = {  {&_swigt__p_FIX__SwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Symbol[] = {  {&_swigt__p_FIX__Symbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SymbolSfx[] = {  {&_swigt__p_FIX__SymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SynchronizedApplication[] = {  {&_swigt__p_FIX__SynchronizedApplication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TYPE__Type[] = {  {&_swigt__p_FIX__TYPE__Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTIMEONLY[] = {  {&_swigt__p_FIX__TZTIMEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTIMESTAMP[] = {  {&_swigt__p_FIX__TZTIMESTAMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTransactTime[] = {  {&_swigt__p_FIX__TZTransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TagNotDefinedForMessage[] = {  {&_swigt__p_FIX__TagNotDefinedForMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TagOutOfOrder[] = {  {&_swigt__p_FIX__TagOutOfOrder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetCompID[] = {  {&_swigt__p_FIX__TargetCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetLocationID[] = {  {&_swigt__p_FIX__TargetLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyID[] = {  {&_swigt__p_FIX__TargetPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyIDSource[] = {  {&_swigt__p_FIX__TargetPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyRole[] = {  {&_swigt__p_FIX__TargetPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategy[] = {  {&_swigt__p_FIX__TargetStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategyParameters[] = {  {&_swigt__p_FIX__TargetStrategyParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategyPerformance[] = {  {&_swigt__p_FIX__TargetStrategyPerformance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetSubID[] = {  {&_swigt__p_FIX__TargetSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TaxAdvantageType[] = {  {&_swigt__p_FIX__TaxAdvantageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TerminationType[] = {  {&_swigt__p_FIX__TerminationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TestMessageIndicator[] = {  {&_swigt__p_FIX__TestMessageIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TestReqID[] = {  {&_swigt__p_FIX__TestReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Text[] = {  {&_swigt__p_FIX__Text, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ThresholdAmount[] = {  {&_swigt__p_FIX__ThresholdAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickDirection[] = {  {&_swigt__p_FIX__TickDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickIncrement[] = {  {&_swigt__p_FIX__TickIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickRuleType[] = {  {&_swigt__p_FIX__TickRuleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TierCode[] = {  {&_swigt__p_FIX__TierCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeBracket[] = {  {&_swigt__p_FIX__TimeBracket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeInForce[] = {  {&_swigt__p_FIX__TimeInForce, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeToExpiration[] = {  {&_swigt__p_FIX__TimeToExpiration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeUnit[] = {  {&_swigt__p_FIX__TimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoAccQuotes[] = {  {&_swigt__p_FIX__TotNoAccQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoAllocs[] = {  {&_swigt__p_FIX__TotNoAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoCxldQuotes[] = {  {&_swigt__p_FIX__TotNoCxldQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoFills[] = {  {&_swigt__p_FIX__TotNoFills, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoOrders[] = {  {&_swigt__p_FIX__TotNoOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoQuoteEntries[] = {  {&_swigt__p_FIX__TotNoQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoRejQuotes[] = {  {&_swigt__p_FIX__TotNoRejQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoRelatedSym[] = {  {&_swigt__p_FIX__TotNoRelatedSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoSecurityTypes[] = {  {&_swigt__p_FIX__TotNoSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoStrikes[] = {  {&_swigt__p_FIX__TotNoStrikes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumAssignmentReports[] = {  {&_swigt__p_FIX__TotNumAssignmentReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumReports[] = {  {&_swigt__p_FIX__TotNumReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumTradeReports[] = {  {&_swigt__p_FIX__TotNumTradeReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotQuoteEntries[] = {  {&_swigt__p_FIX__TotQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalAccruedInterestAmt[] = {  {&_swigt__p_FIX__TotalAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalAffectedOrders[] = {  {&_swigt__p_FIX__TotalAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNetValue[] = {  {&_swigt__p_FIX__TotalNetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumPosReports[] = {  {&_swigt__p_FIX__TotalNumPosReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumSecurities[] = {  {&_swigt__p_FIX__TotalNumSecurities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumSecurityTypes[] = {  {&_swigt__p_FIX__TotalNumSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalTakedown[] = {  {&_swigt__p_FIX__TotalTakedown, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTraded[] = {  {&_swigt__p_FIX__TotalVolumeTraded, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTradedDate[] = {  {&_swigt__p_FIX__TotalVolumeTradedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTradedTime[] = {  {&_swigt__p_FIX__TotalVolumeTradedTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesCloseTime[] = {  {&_swigt__p_FIX__TradSesCloseTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesEndTime[] = {  {&_swigt__p_FIX__TradSesEndTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesEvent[] = {  {&_swigt__p_FIX__TradSesEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesMethod[] = {  {&_swigt__p_FIX__TradSesMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesMode[] = {  {&_swigt__p_FIX__TradSesMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesOpenTime[] = {  {&_swigt__p_FIX__TradSesOpenTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesPreCloseTime[] = {  {&_swigt__p_FIX__TradSesPreCloseTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesReqID[] = {  {&_swigt__p_FIX__TradSesReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStartTime[] = {  {&_swigt__p_FIX__TradSesStartTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStatus[] = {  {&_swigt__p_FIX__TradSesStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStatusRejReason[] = {  {&_swigt__p_FIX__TradSesStatusRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesUpdateAction[] = {  {&_swigt__p_FIX__TradSesUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeAllocIndicator[] = {  {&_swigt__p_FIX__TradeAllocIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeCondition[] = {  {&_swigt__p_FIX__TradeCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeDate[] = {  {&_swigt__p_FIX__TradeDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeHandlingInstr[] = {  {&_swigt__p_FIX__TradeHandlingInstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeID[] = {  {&_swigt__p_FIX__TradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeInputDevice[] = {  {&_swigt__p_FIX__TradeInputDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeInputSource[] = {  {&_swigt__p_FIX__TradeInputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeLegRefID[] = {  {&_swigt__p_FIX__TradeLegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeLinkID[] = {  {&_swigt__p_FIX__TradeLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeOriginationDate[] = {  {&_swigt__p_FIX__TradeOriginationDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradePublishIndicator[] = {  {&_swigt__p_FIX__TradePublishIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportID[] = {  {&_swigt__p_FIX__TradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportRefID[] = {  {&_swigt__p_FIX__TradeReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportRejectReason[] = {  {&_swigt__p_FIX__TradeReportRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportTransType[] = {  {&_swigt__p_FIX__TradeReportTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportType[] = {  {&_swigt__p_FIX__TradeReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestID[] = {  {&_swigt__p_FIX__TradeRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestResult[] = {  {&_swigt__p_FIX__TradeRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestStatus[] = {  {&_swigt__p_FIX__TradeRequestStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestType[] = {  {&_swigt__p_FIX__TradeRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeType[] = {  {&_swigt__p_FIX__TradeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeVolume[] = {  {&_swigt__p_FIX__TradeVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradedFlatSwitch[] = {  {&_swigt__p_FIX__TradedFlatSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingCurrency[] = {  {&_swigt__p_FIX__TradingCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingReferencePrice[] = {  {&_swigt__p_FIX__TradingReferencePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionDesc[] = {  {&_swigt__p_FIX__TradingSessionDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionID[] = {  {&_swigt__p_FIX__TradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionSubID[] = {  {&_swigt__p_FIX__TradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Trailer[] = {  {&_swigt__p_FIX__Trailer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransBkdTime[] = {  {&_swigt__p_FIX__TransBkdTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransactTime[] = {  {&_swigt__p_FIX__TransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransferReason[] = {  {&_swigt__p_FIX__TransferReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdMatchID[] = {  {&_swigt__p_FIX__TrdMatchID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestamp[] = {  {&_swigt__p_FIX__TrdRegTimestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestampOrigin[] = {  {&_swigt__p_FIX__TrdRegTimestampOrigin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestampType[] = {  {&_swigt__p_FIX__TrdRegTimestampType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRepIndicator[] = {  {&_swigt__p_FIX__TrdRepIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRepPartyRole[] = {  {&_swigt__p_FIX__TrdRepPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRptStatus[] = {  {&_swigt__p_FIX__TrdRptStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdSubType[] = {  {&_swigt__p_FIX__TrdSubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdType[] = {  {&_swigt__p_FIX__TrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerAction[] = {  {&_swigt__p_FIX__TriggerAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerNewPrice[] = {  {&_swigt__p_FIX__TriggerNewPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerNewQty[] = {  {&_swigt__p_FIX__TriggerNewQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerOrderType[] = {  {&_swigt__p_FIX__TriggerOrderType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPrice[] = {  {&_swigt__p_FIX__TriggerPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceDirection[] = {  {&_swigt__p_FIX__TriggerPriceDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceType[] = {  {&_swigt__p_FIX__TriggerPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceTypeScope[] = {  {&_swigt__p_FIX__TriggerPriceTypeScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityDesc[] = {  {&_swigt__p_FIX__TriggerSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityID[] = {  {&_swigt__p_FIX__TriggerSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityIDSource[] = {  {&_swigt__p_FIX__TriggerSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSymbol[] = {  {&_swigt__p_FIX__TriggerSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerTradingSessionID[] = {  {&_swigt__p_FIX__TriggerTradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerTradingSessionSubID[] = {  {&_swigt__p_FIX__TriggerTradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerType[] = {  {&_swigt__p_FIX__TriggerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__URLLink[] = {  {&_swigt__p_FIX__URLLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCDATE[] = {  {&_swigt__p_FIX__UTCDATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCDATEONLY[] = {  {&_swigt__p_FIX__UTCDATEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCTIMEONLY[] = {  {&_swigt__p_FIX__UTCTIMEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCTIMESTAMP[] = {  {&_swigt__p_FIX__UTCTIMESTAMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAdjustedQuantity[] = {  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAllocationPercent[] = {  {&_swigt__p_FIX__UnderlyingAllocationPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAttachmentPoint[] = {  {&_swigt__p_FIX__UnderlyingAttachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCFICode[] = {  {&_swigt__p_FIX__UnderlyingCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCPProgram[] = {  {&_swigt__p_FIX__UnderlyingCPProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCPRegType[] = {  {&_swigt__p_FIX__UnderlyingCPRegType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCapValue[] = {  {&_swigt__p_FIX__UnderlyingCapValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCashAmount[] = {  {&_swigt__p_FIX__UnderlyingCashAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCashType[] = {  {&_swigt__p_FIX__UnderlyingCashType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCollectAmount[] = {  {&_swigt__p_FIX__UnderlyingCollectAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingContractMultiplier[] = {  {&_swigt__p_FIX__UnderlyingContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingContractMultiplierUnit[] = {  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCountryOfIssue[] = {  {&_swigt__p_FIX__UnderlyingCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCouponPaymentDate[] = {  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCouponRate[] = {  {&_swigt__p_FIX__UnderlyingCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCreditRating[] = {  {&_swigt__p_FIX__UnderlyingCreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCurrency[] = {  {&_swigt__p_FIX__UnderlyingCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCurrentValue[] = {  {&_swigt__p_FIX__UnderlyingCurrentValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDeliveryAmount[] = {  {&_swigt__p_FIX__UnderlyingDeliveryAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDetachmentPoint[] = {  {&_swigt__p_FIX__UnderlyingDetachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDirtyPrice[] = {  {&_swigt__p_FIX__UnderlyingDirtyPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingEndPrice[] = {  {&_swigt__p_FIX__UnderlyingEndPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingEndValue[] = {  {&_swigt__p_FIX__UnderlyingEndValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingExerciseStyle[] = {  {&_swigt__p_FIX__UnderlyingExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFXRate[] = {  {&_swigt__p_FIX__UnderlyingFXRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFXRateCalc[] = {  {&_swigt__p_FIX__UnderlyingFXRateCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFactor[] = {  {&_swigt__p_FIX__UnderlyingFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFlowScheduleType[] = {  {&_swigt__p_FIX__UnderlyingFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIDSource[] = {  {&_swigt__p_FIX__UnderlyingIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrRegistry[] = {  {&_swigt__p_FIX__UnderlyingInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyID[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyRole[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartySubID[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIssueDate[] = {  {&_swigt__p_FIX__UnderlyingIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIssuer[] = {  {&_swigt__p_FIX__UnderlyingIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLastPx[] = {  {&_swigt__p_FIX__UnderlyingLastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLastQty[] = {  {&_swigt__p_FIX__UnderlyingLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegCFICode[] = {  {&_swigt__p_FIX__UnderlyingLegCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityDate[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityMonthYear[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityTime[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegOptAttribute[] = {  {&_swigt__p_FIX__UnderlyingLegOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegPutOrCall[] = {  {&_swigt__p_FIX__UnderlyingLegPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityAltID[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityAltIDSource[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityDesc[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityExchange[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityID[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityIDSource[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecuritySubType[] = {  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityType[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegStrikePrice[] = {  {&_swigt__p_FIX__UnderlyingLegStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSymbol[] = {  {&_swigt__p_FIX__UnderlyingLegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSymbolSfx[] = {  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLocaleOfIssue[] = {  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityDate[] = {  {&_swigt__p_FIX__UnderlyingMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityDay[] = {  {&_swigt__p_FIX__UnderlyingMaturityDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityMonthYear[] = {  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityTime[] = {  {&_swigt__p_FIX__UnderlyingMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingOptAttribute[] = {  {&_swigt__p_FIX__UnderlyingOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPayAmount[] = {  {&_swigt__p_FIX__UnderlyingPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceDeterminationMethod[] = {  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceUnitOfMeasure[] = {  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingProduct[] = {  {&_swigt__p_FIX__UnderlyingProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPutOrCall[] = {  {&_swigt__p_FIX__UnderlyingPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPx[] = {  {&_swigt__p_FIX__UnderlyingPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingQty[] = {  {&_swigt__p_FIX__UnderlyingQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRedemptionDate[] = {  {&_swigt__p_FIX__UnderlyingRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepoCollateralSecurityType[] = {  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepurchaseRate[] = {  {&_swigt__p_FIX__UnderlyingRepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepurchaseTerm[] = {  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRestructuringType[] = {  {&_swigt__p_FIX__UnderlyingRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityAltID[] = {  {&_swigt__p_FIX__UnderlyingSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityAltIDSource[] = {  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityDesc[] = {  {&_swigt__p_FIX__UnderlyingSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityExchange[] = {  {&_swigt__p_FIX__UnderlyingSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityID[] = {  {&_swigt__p_FIX__UnderlyingSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityIDSource[] = {  {&_swigt__p_FIX__UnderlyingSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecuritySubType[] = {  {&_swigt__p_FIX__UnderlyingSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityType[] = {  {&_swigt__p_FIX__UnderlyingSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSeniority[] = {  {&_swigt__p_FIX__UnderlyingSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlMethod[] = {  {&_swigt__p_FIX__UnderlyingSettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlPrice[] = {  {&_swigt__p_FIX__UnderlyingSettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlPriceType[] = {  {&_swigt__p_FIX__UnderlyingSettlPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementDate[] = {  {&_swigt__p_FIX__UnderlyingSettlementDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementStatus[] = {  {&_swigt__p_FIX__UnderlyingSettlementStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementType[] = {  {&_swigt__p_FIX__UnderlyingSettlementType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStartValue[] = {  {&_swigt__p_FIX__UnderlyingStartValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStipType[] = {  {&_swigt__p_FIX__UnderlyingStipType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStipValue[] = {  {&_swigt__p_FIX__UnderlyingStipValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStrikeCurrency[] = {  {&_swigt__p_FIX__UnderlyingStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStrikePrice[] = {  {&_swigt__p_FIX__UnderlyingStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSymbol[] = {  {&_swigt__p_FIX__UnderlyingSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSymbolSfx[] = {  {&_swigt__p_FIX__UnderlyingSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTimeUnit[] = {  {&_swigt__p_FIX__UnderlyingTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTradingSessionID[] = {  {&_swigt__p_FIX__UnderlyingTradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTradingSessionSubID[] = {  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingUnitOfMeasure[] = {  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingUnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyID[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyRole[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartySubID[] = {  {&_swigt__p_FIX__UndlyInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnitOfMeasure[] = {  {&_swigt__p_FIX__UnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsolicitedIndicator[] = {  {&_swigt__p_FIX__UnsolicitedIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsupportedMessageType[] = {  {&_swigt__p_FIX__UnsupportedMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsupportedVersion[] = {  {&_swigt__p_FIX__UnsupportedVersion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Urgency[] = {  {&_swigt__p_FIX__Urgency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserRequestID[] = {  {&_swigt__p_FIX__UserRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserRequestType[] = {  {&_swigt__p_FIX__UserRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserStatus[] = {  {&_swigt__p_FIX__UserStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserStatusText[] = {  {&_swigt__p_FIX__UserStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Username[] = {  {&_swigt__p_FIX__Username, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcDateField[] = {  {&_swigt__p_FIX__UtcDateField, 0, 0, 0},  {&_swigt__p_FIX__MDEntryDate, _p_FIX__MDEntryDateTo_p_FIX__UtcDateField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedDate, _p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcTimeOnlyField[] = {  {&_swigt__p_FIX__UtcTimeOnlyField, 0, 0, 0},  {&_swigt__p_FIX__MDEntryTime, _p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__ComplexEventStartTime, _p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedTime, _p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__ComplexEventEndTime, _p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcTimeStampField[] = {  {&_swigt__p_FIX__TradSesEndTime, _p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigTime, _p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigOrdModTime, _p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesOpenTime, _p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, 0, 0, 0},  {&_swigt__p_FIX__ExecValuationPoint, _p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ComplexEventStartDate, _p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SideTimeInForce, _p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ExpireTime, _p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TransBkdTime, _p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesPreCloseTime, _p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesCloseTime, _p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesStartTime, _p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__StrikeTime, _p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__LastUpdateTime, _p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__QuoteSetValidUntilTime, _p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ValidUntilTime, _p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestamp, _p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ContraTradeTime, _p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TransactTime, _p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestamp, _p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigSendingTime, _p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ComplexEventEndDate, _p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__HopSendingTime, _p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSendingTime, _p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SendingTime, _p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__EffectiveTime, _p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValidUntilTime[] = {  {&_swigt__p_FIX__ValidUntilTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValuationMethod[] = {  {&_swigt__p_FIX__ValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValueOfFutures[] = {  {&_swigt__p_FIX__ValueOfFutures, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__VenueType[] = {  {&_swigt__p_FIX__VenueType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Volatility[] = {  {&_swigt__p_FIX__Volatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WaveNo[] = {  {&_swigt__p_FIX__WaveNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WorkingIndicator[] = {  {&_swigt__p_FIX__WorkingIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WtAverageLiquidity[] = {  {&_swigt__p_FIX__WtAverageLiquidity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XMLDATA[] = {  {&_swigt__p_FIX__XMLDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XmlData[] = {  {&_swigt__p_FIX__XmlData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XmlDataLen[] = {  {&_swigt__p_FIX__XmlDataLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Yield[] = {  {&_swigt__p_FIX__Yield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldCalcDate[] = {  {&_swigt__p_FIX__YieldCalcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionDate[] = {  {&_swigt__p_FIX__YieldRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionPrice[] = {  {&_swigt__p_FIX__YieldRedemptionPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionPriceType[] = {  {&_swigt__p_FIX__YieldRedemptionPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldType[] = {  {&_swigt__p_FIX__YieldType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fields[] = {  {&_swigt__p_Fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Group[] = {  {&_swigt__p_Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Groups[] = {  {&_swigt__p_Groups, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntArray[] = {  {&_swigt__p_IntArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntField[] = {  {&_swigt__p_IntField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Log[] = {  {&_swigt__p_Log, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogFactory[] = {  {&_swigt__p_LogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageStore[] = {  {&_swigt__p_MessageStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageStoreFactory[] = {  {&_swigt__p_MessageStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MsgType[] = {  {&_swigt__p_MsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mutex[] = {  {&_swigt__p_Mutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Responder[] = {  {&_swigt__p_Responder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SessionID[] = {  {&_swigt__p_SessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StringField[] = {  {&_swigt__p_StringField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeRange[] = {  {&_swigt__p_TimeRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcDate[] = {  {&_swigt__p_UtcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcDateField[] = {  {&_swigt__p_UtcDateField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcTimeOnly[] = {  {&_swigt__p_UtcTimeOnly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcTimeStamp[] = {  {&_swigt__p_UtcTimeStamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_g_const_iterator[] = {  {&_swigt__p_g_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_g_iterator[] = {  {&_swigt__p_g_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_IntArray, _p_IntArrayTo_p_int, 0, 0},  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_message_order[] = {  {&_swigt__p_message_order, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FIX__DataDictionary[] = {  {&_swigt__p_p_FIX__DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__istream[] = {  {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_FIX__SessionID_t[] = {  {&_swigt__p_std__setT_FIX__SessionID_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string__size_type[] = {  {&_swigt__p_std__string__size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ApplVerID,
  _swigc__p_Application,
  _swigc__p_BeginString,
  _swigc__p_DOMDocumentPtr,
  _swigc__p_Data,
  _swigc__p_DataDictionary,
  _swigc__p_DataDictionaryProvider,
  _swigc__p_Dictionaries,
  _swigc__p_DoubleField,
  _swigc__p_FIX__AMT,
  _swigc__p_FIX__Acceptor,
  _swigc__p_FIX__Account,
  _swigc__p_FIX__AccountType,
  _swigc__p_FIX__AccruedInterestAmt,
  _swigc__p_FIX__AccruedInterestRate,
  _swigc__p_FIX__AcctIDSource,
  _swigc__p_FIX__Adjustment,
  _swigc__p_FIX__AdjustmentType,
  _swigc__p_FIX__AdvId,
  _swigc__p_FIX__AdvRefID,
  _swigc__p_FIX__AdvSide,
  _swigc__p_FIX__AdvTransType,
  _swigc__p_FIX__AffectedOrderID,
  _swigc__p_FIX__AffectedSecondaryOrderID,
  _swigc__p_FIX__AffirmStatus,
  _swigc__p_FIX__AggregatedBook,
  _swigc__p_FIX__AggressorIndicator,
  _swigc__p_FIX__AgreementCurrency,
  _swigc__p_FIX__AgreementDate,
  _swigc__p_FIX__AgreementDesc,
  _swigc__p_FIX__AgreementID,
  _swigc__p_FIX__AllocAccount,
  _swigc__p_FIX__AllocAccountType,
  _swigc__p_FIX__AllocAccruedInterestAmt,
  _swigc__p_FIX__AllocAcctIDSource,
  _swigc__p_FIX__AllocAvgPx,
  _swigc__p_FIX__AllocCancReplaceReason,
  _swigc__p_FIX__AllocClearingFeeIndicator,
  _swigc__p_FIX__AllocCustomerCapacity,
  _swigc__p_FIX__AllocHandlInst,
  _swigc__p_FIX__AllocID,
  _swigc__p_FIX__AllocInterestAtMaturity,
  _swigc__p_FIX__AllocIntermedReqType,
  _swigc__p_FIX__AllocLinkID,
  _swigc__p_FIX__AllocLinkType,
  _swigc__p_FIX__AllocMethod,
  _swigc__p_FIX__AllocNetMoney,
  _swigc__p_FIX__AllocNoOrdersType,
  _swigc__p_FIX__AllocPositionEffect,
  _swigc__p_FIX__AllocPrice,
  _swigc__p_FIX__AllocQty,
  _swigc__p_FIX__AllocRejCode,
  _swigc__p_FIX__AllocReportID,
  _swigc__p_FIX__AllocReportRefID,
  _swigc__p_FIX__AllocReportType,
  _swigc__p_FIX__AllocSettlCurrAmt,
  _swigc__p_FIX__AllocSettlCurrency,
  _swigc__p_FIX__AllocSettlInstType,
  _swigc__p_FIX__AllocShares,
  _swigc__p_FIX__AllocStatus,
  _swigc__p_FIX__AllocText,
  _swigc__p_FIX__AllocTransType,
  _swigc__p_FIX__AllocType,
  _swigc__p_FIX__AllowableOneSidednessCurr,
  _swigc__p_FIX__AllowableOneSidednessPct,
  _swigc__p_FIX__AllowableOneSidednessValue,
  _swigc__p_FIX__AltMDSourceID,
  _swigc__p_FIX__ApplBegSeqNum,
  _swigc__p_FIX__ApplEndSeqNum,
  _swigc__p_FIX__ApplExtID,
  _swigc__p_FIX__ApplID,
  _swigc__p_FIX__ApplLastSeqNum,
  _swigc__p_FIX__ApplNewSeqNum,
  _swigc__p_FIX__ApplQueueAction,
  _swigc__p_FIX__ApplQueueDepth,
  _swigc__p_FIX__ApplQueueMax,
  _swigc__p_FIX__ApplQueueResolution,
  _swigc__p_FIX__ApplReportID,
  _swigc__p_FIX__ApplReportType,
  _swigc__p_FIX__ApplReqID,
  _swigc__p_FIX__ApplReqType,
  _swigc__p_FIX__ApplResendFlag,
  _swigc__p_FIX__ApplResponseError,
  _swigc__p_FIX__ApplResponseID,
  _swigc__p_FIX__ApplResponseType,
  _swigc__p_FIX__ApplSeqNum,
  _swigc__p_FIX__ApplTotalMessageCount,
  _swigc__p_FIX__ApplVerID,
  _swigc__p_FIX__Application,
  _swigc__p_FIX__AsOfIndicator,
  _swigc__p_FIX__AsgnRptID,
  _swigc__p_FIX__AssignmentMethod,
  _swigc__p_FIX__AssignmentUnit,
  _swigc__p_FIX__AttachmentPoint,
  _swigc__p_FIX__AutoAcceptIndicator,
  _swigc__p_FIX__AvgParPx,
  _swigc__p_FIX__AvgPrxPrecision,
  _swigc__p_FIX__AvgPx,
  _swigc__p_FIX__AvgPxIndicator,
  _swigc__p_FIX__AvgPxPrecision,
  _swigc__p_FIX__BOOLEAN,
  _swigc__p_FIX__BasisFeatureDate,
  _swigc__p_FIX__BasisFeaturePrice,
  _swigc__p_FIX__BasisPxType,
  _swigc__p_FIX__BeginSeqNo,
  _swigc__p_FIX__BeginString,
  _swigc__p_FIX__Benchmark,
  _swigc__p_FIX__BenchmarkCurveCurrency,
  _swigc__p_FIX__BenchmarkCurveName,
  _swigc__p_FIX__BenchmarkCurvePoint,
  _swigc__p_FIX__BenchmarkPrice,
  _swigc__p_FIX__BenchmarkPriceType,
  _swigc__p_FIX__BenchmarkSecurityID,
  _swigc__p_FIX__BenchmarkSecurityIDSource,
  _swigc__p_FIX__BidDescriptor,
  _swigc__p_FIX__BidDescriptorType,
  _swigc__p_FIX__BidForwardPoints,
  _swigc__p_FIX__BidForwardPoints2,
  _swigc__p_FIX__BidID,
  _swigc__p_FIX__BidPx,
  _swigc__p_FIX__BidRequestTransType,
  _swigc__p_FIX__BidSize,
  _swigc__p_FIX__BidSpotRate,
  _swigc__p_FIX__BidSwapPoints,
  _swigc__p_FIX__BidTradeType,
  _swigc__p_FIX__BidType,
  _swigc__p_FIX__BidYield,
  _swigc__p_FIX__BodyLength,
  _swigc__p_FIX__BookingRefID,
  _swigc__p_FIX__BookingType,
  _swigc__p_FIX__BookingUnit,
  _swigc__p_FIX__BoolField,
  _swigc__p_FIX__BrokerOfCredit,
  _swigc__p_FIX__BusinessRejectReason,
  _swigc__p_FIX__BusinessRejectRefID,
  _swigc__p_FIX__BuyVolume,
  _swigc__p_FIX__CFICode,
  _swigc__p_FIX__CHAR,
  _swigc__p_FIX__COUNTRY,
  _swigc__p_FIX__CPProgram,
  _swigc__p_FIX__CPRegType,
  _swigc__p_FIX__CURRENCY,
  _swigc__p_FIX__CalculatedCcyLastQty,
  _swigc__p_FIX__CancellationRights,
  _swigc__p_FIX__CapPrice,
  _swigc__p_FIX__CardExpDate,
  _swigc__p_FIX__CardHolderName,
  _swigc__p_FIX__CardIssNo,
  _swigc__p_FIX__CardIssNum,
  _swigc__p_FIX__CardNumber,
  _swigc__p_FIX__CardStartDate,
  _swigc__p_FIX__CashDistribAgentAcctName,
  _swigc__p_FIX__CashDistribAgentAcctNumber,
  _swigc__p_FIX__CashDistribAgentCode,
  _swigc__p_FIX__CashDistribAgentName,
  _swigc__p_FIX__CashDistribCurr,
  _swigc__p_FIX__CashDistribPayRef,
  _swigc__p_FIX__CashMargin,
  _swigc__p_FIX__CashOrderQty,
  _swigc__p_FIX__CashOutstanding,
  _swigc__p_FIX__CashSettlAgentAcctName,
  _swigc__p_FIX__CashSettlAgentAcctNum,
  _swigc__p_FIX__CashSettlAgentCode,
  _swigc__p_FIX__CashSettlAgentContactName,
  _swigc__p_FIX__CashSettlAgentContactPhone,
  _swigc__p_FIX__CashSettlAgentName,
  _swigc__p_FIX__CcyAmt,
  _swigc__p_FIX__CharField,
  _swigc__p_FIX__CheckSum,
  _swigc__p_FIX__CheckSumField,
  _swigc__p_FIX__ClOrdID,
  _swigc__p_FIX__ClOrdLinkID,
  _swigc__p_FIX__ClearingAccount,
  _swigc__p_FIX__ClearingBusinessDate,
  _swigc__p_FIX__ClearingFeeIndicator,
  _swigc__p_FIX__ClearingFirm,
  _swigc__p_FIX__ClearingInstruction,
  _swigc__p_FIX__ClientBidID,
  _swigc__p_FIX__ClientID,
  _swigc__p_FIX__CollAction,
  _swigc__p_FIX__CollApplType,
  _swigc__p_FIX__CollAsgnID,
  _swigc__p_FIX__CollAsgnReason,
  _swigc__p_FIX__CollAsgnRefID,
  _swigc__p_FIX__CollAsgnRejectReason,
  _swigc__p_FIX__CollAsgnRespType,
  _swigc__p_FIX__CollAsgnTransType,
  _swigc__p_FIX__CollInquiryID,
  _swigc__p_FIX__CollInquiryQualifier,
  _swigc__p_FIX__CollInquiryResult,
  _swigc__p_FIX__CollInquiryStatus,
  _swigc__p_FIX__CollReqID,
  _swigc__p_FIX__CollRespID,
  _swigc__p_FIX__CollRptID,
  _swigc__p_FIX__CollStatus,
  _swigc__p_FIX__CommCurrency,
  _swigc__p_FIX__CommType,
  _swigc__p_FIX__Commission,
  _swigc__p_FIX__ComplexEventCondition,
  _swigc__p_FIX__ComplexEventEndDate,
  _swigc__p_FIX__ComplexEventEndTime,
  _swigc__p_FIX__ComplexEventPrice,
  _swigc__p_FIX__ComplexEventPriceBoundaryMethod,
  _swigc__p_FIX__ComplexEventPriceBoundaryPrecision,
  _swigc__p_FIX__ComplexEventPriceTimeType,
  _swigc__p_FIX__ComplexEventStartDate,
  _swigc__p_FIX__ComplexEventStartTime,
  _swigc__p_FIX__ComplexEventType,
  _swigc__p_FIX__ComplexOptPayoutAmount,
  _swigc__p_FIX__ComplianceID,
  _swigc__p_FIX__Concession,
  _swigc__p_FIX__ConfigError,
  _swigc__p_FIX__ConfirmID,
  _swigc__p_FIX__ConfirmRefID,
  _swigc__p_FIX__ConfirmRejReason,
  _swigc__p_FIX__ConfirmReqID,
  _swigc__p_FIX__ConfirmStatus,
  _swigc__p_FIX__ConfirmTransType,
  _swigc__p_FIX__ConfirmType,
  _swigc__p_FIX__ContAmtCurr,
  _swigc__p_FIX__ContAmtType,
  _swigc__p_FIX__ContAmtValue,
  _swigc__p_FIX__ContIntRptID,
  _swigc__p_FIX__ContingencyType,
  _swigc__p_FIX__ContraBroker,
  _swigc__p_FIX__ContraLegRefID,
  _swigc__p_FIX__ContraTradeQty,
  _swigc__p_FIX__ContraTradeTime,
  _swigc__p_FIX__ContraTrader,
  _swigc__p_FIX__ContractMultiplier,
  _swigc__p_FIX__ContractMultiplierUnit,
  _swigc__p_FIX__ContractSettlMonth,
  _swigc__p_FIX__ContraryInstructionIndicator,
  _swigc__p_FIX__CopyMsgIndicator,
  _swigc__p_FIX__CorporateAction,
  _swigc__p_FIX__Country,
  _swigc__p_FIX__CountryOfIssue,
  _swigc__p_FIX__CouponPaymentDate,
  _swigc__p_FIX__CouponRate,
  _swigc__p_FIX__CoveredOrUncovered,
  _swigc__p_FIX__CreditRating,
  _swigc__p_FIX__CrossID,
  _swigc__p_FIX__CrossPercent,
  _swigc__p_FIX__CrossPrioritization,
  _swigc__p_FIX__CrossType,
  _swigc__p_FIX__CstmApplVerID,
  _swigc__p_FIX__CumQty,
  _swigc__p_FIX__Currency,
  _swigc__p_FIX__CurrencyRatio,
  _swigc__p_FIX__CustDirectedOrder,
  _swigc__p_FIX__CustOrderCapacity,
  _swigc__p_FIX__CustOrderHandlingInst,
  _swigc__p_FIX__CustomerOrFirm,
  _swigc__p_FIX__CxlQty,
  _swigc__p_FIX__CxlRejReason,
  _swigc__p_FIX__CxlRejResponseTo,
  _swigc__p_FIX__CxlType,
  _swigc__p_FIX__DATA,
  _swigc__p_FIX__DAYOFMONTH,
  _swigc__p_FIX__DKReason,
  _swigc__p_FIX__DataDictionary,
  _swigc__p_FIX__DataDictionaryNotFound,
  _swigc__p_FIX__DateOfBirth,
  _swigc__p_FIX__DatedDate,
  _swigc__p_FIX__DayAvgPx,
  _swigc__p_FIX__DayBookingInst,
  _swigc__p_FIX__DayCumQty,
  _swigc__p_FIX__DayOrderQty,
  _swigc__p_FIX__DealingCapacity,
  _swigc__p_FIX__DefBidSize,
  _swigc__p_FIX__DefOfferSize,
  _swigc__p_FIX__DefaultApplExtID,
  _swigc__p_FIX__DefaultApplVerID,
  _swigc__p_FIX__DefaultCstmApplVerID,
  _swigc__p_FIX__DefaultVerIndicator,
  _swigc__p_FIX__DeleteReason,
  _swigc__p_FIX__DeliverToCompID,
  _swigc__p_FIX__DeliverToLocationID,
  _swigc__p_FIX__DeliverToSubID,
  _swigc__p_FIX__DeliveryDate,
  _swigc__p_FIX__DeliveryForm,
  _swigc__p_FIX__DeliveryType,
  _swigc__p_FIX__DerivFlexProductEligibilityIndicator,
  _swigc__p_FIX__DerivativeCFICode,
  _swigc__p_FIX__DerivativeCapPrice,
  _swigc__p_FIX__DerivativeContractMultiplier,
  _swigc__p_FIX__DerivativeContractMultiplierUnit,
  _swigc__p_FIX__DerivativeContractSettlMonth,
  _swigc__p_FIX__DerivativeCountryOfIssue,
  _swigc__p_FIX__DerivativeEncodedIssuer,
  _swigc__p_FIX__DerivativeEncodedIssuerLen,
  _swigc__p_FIX__DerivativeEncodedSecurityDesc,
  _swigc__p_FIX__DerivativeEncodedSecurityDescLen,
  _swigc__p_FIX__DerivativeEventDate,
  _swigc__p_FIX__DerivativeEventPx,
  _swigc__p_FIX__DerivativeEventText,
  _swigc__p_FIX__DerivativeEventTime,
  _swigc__p_FIX__DerivativeEventType,
  _swigc__p_FIX__DerivativeExerciseStyle,
  _swigc__p_FIX__DerivativeFloorPrice,
  _swigc__p_FIX__DerivativeFlowScheduleType,
  _swigc__p_FIX__DerivativeFuturesValuationMethod,
  _swigc__p_FIX__DerivativeInstrAttribType,
  _swigc__p_FIX__DerivativeInstrAttribValue,
  _swigc__p_FIX__DerivativeInstrRegistry,
  _swigc__p_FIX__DerivativeInstrmtAssignmentMethod,
  _swigc__p_FIX__DerivativeInstrumentPartyID,
  _swigc__p_FIX__DerivativeInstrumentPartyIDSource,
  _swigc__p_FIX__DerivativeInstrumentPartyRole,
  _swigc__p_FIX__DerivativeInstrumentPartySubID,
  _swigc__p_FIX__DerivativeInstrumentPartySubIDType,
  _swigc__p_FIX__DerivativeIssueDate,
  _swigc__p_FIX__DerivativeIssuer,
  _swigc__p_FIX__DerivativeListMethod,
  _swigc__p_FIX__DerivativeLocaleOfIssue,
  _swigc__p_FIX__DerivativeMaturityDate,
  _swigc__p_FIX__DerivativeMaturityMonthYear,
  _swigc__p_FIX__DerivativeMaturityTime,
  _swigc__p_FIX__DerivativeMinPriceIncrement,
  _swigc__p_FIX__DerivativeMinPriceIncrementAmount,
  _swigc__p_FIX__DerivativeNTPositionLimit,
  _swigc__p_FIX__DerivativeOptAttribute,
  _swigc__p_FIX__DerivativeOptPayAmount,
  _swigc__p_FIX__DerivativePositionLimit,
  _swigc__p_FIX__DerivativePriceQuoteMethod,
  _swigc__p_FIX__DerivativePriceUnitOfMeasure,
  _swigc__p_FIX__DerivativePriceUnitOfMeasureQty,
  _swigc__p_FIX__DerivativeProduct,
  _swigc__p_FIX__DerivativeProductComplex,
  _swigc__p_FIX__DerivativePutOrCall,
  _swigc__p_FIX__DerivativeSecurityAltID,
  _swigc__p_FIX__DerivativeSecurityAltIDSource,
  _swigc__p_FIX__DerivativeSecurityDesc,
  _swigc__p_FIX__DerivativeSecurityExchange,
  _swigc__p_FIX__DerivativeSecurityGroup,
  _swigc__p_FIX__DerivativeSecurityID,
  _swigc__p_FIX__DerivativeSecurityIDSource,
  _swigc__p_FIX__DerivativeSecurityStatus,
  _swigc__p_FIX__DerivativeSecuritySubType,
  _swigc__p_FIX__DerivativeSecurityType,
  _swigc__p_FIX__DerivativeSecurityXML,
  _swigc__p_FIX__DerivativeSecurityXMLLen,
  _swigc__p_FIX__DerivativeSecurityXMLSchema,
  _swigc__p_FIX__DerivativeSettlMethod,
  _swigc__p_FIX__DerivativeSettleOnOpenFlag,
  _swigc__p_FIX__DerivativeStateOrProvinceOfIssue,
  _swigc__p_FIX__DerivativeStrikeCurrency,
  _swigc__p_FIX__DerivativeStrikeMultiplier,
  _swigc__p_FIX__DerivativeStrikePrice,
  _swigc__p_FIX__DerivativeStrikeValue,
  _swigc__p_FIX__DerivativeSymbol,
  _swigc__p_FIX__DerivativeSymbolSfx,
  _swigc__p_FIX__DerivativeTimeUnit,
  _swigc__p_FIX__DerivativeUnitOfMeasure,
  _swigc__p_FIX__DerivativeUnitOfMeasureQty,
  _swigc__p_FIX__DerivativeValuationMethod,
  _swigc__p_FIX__Designation,
  _swigc__p_FIX__DeskID,
  _swigc__p_FIX__DeskOrderHandlingInst,
  _swigc__p_FIX__DeskType,
  _swigc__p_FIX__DeskTypeSource,
  _swigc__p_FIX__DetachmentPoint,
  _swigc__p_FIX__Dictionary,
  _swigc__p_FIX__Dictionary__Data__const_iterator,
  _swigc__p_FIX__DiscretionInst,
  _swigc__p_FIX__DiscretionLimitType,
  _swigc__p_FIX__DiscretionMoveType,
  _swigc__p_FIX__DiscretionOffset,
  _swigc__p_FIX__DiscretionOffsetType,
  _swigc__p_FIX__DiscretionOffsetValue,
  _swigc__p_FIX__DiscretionPrice,
  _swigc__p_FIX__DiscretionRoundDirection,
  _swigc__p_FIX__DiscretionScope,
  _swigc__p_FIX__DisplayHighQty,
  _swigc__p_FIX__DisplayLowQty,
  _swigc__p_FIX__DisplayMethod,
  _swigc__p_FIX__DisplayMinIncr,
  _swigc__p_FIX__DisplayQty,
  _swigc__p_FIX__DisplayWhen,
  _swigc__p_FIX__DistribPaymentMethod,
  _swigc__p_FIX__DistribPercentage,
  _swigc__p_FIX__DividendYield,
  _swigc__p_FIX__DlvyInst,
  _swigc__p_FIX__DlvyInstType,
  _swigc__p_FIX__DoNotSend,
  _swigc__p_FIX__DoubleField,
  _swigc__p_FIX__DueToRelated,
  _swigc__p_FIX__DuplicateFieldNumber,
  _swigc__p_FIX__EFPTrackingError,
  _swigc__p_FIX__EXCHANGE,
  _swigc__p_FIX__EffectiveTime,
  _swigc__p_FIX__EmailThreadID,
  _swigc__p_FIX__EmailType,
  _swigc__p_FIX__EncodedAllocText,
  _swigc__p_FIX__EncodedAllocTextLen,
  _swigc__p_FIX__EncodedHeadline,
  _swigc__p_FIX__EncodedHeadlineLen,
  _swigc__p_FIX__EncodedIssuer,
  _swigc__p_FIX__EncodedIssuerLen,
  _swigc__p_FIX__EncodedLegIssuer,
  _swigc__p_FIX__EncodedLegIssuerLen,
  _swigc__p_FIX__EncodedLegSecurityDesc,
  _swigc__p_FIX__EncodedLegSecurityDescLen,
  _swigc__p_FIX__EncodedListExecInst,
  _swigc__p_FIX__EncodedListExecInstLen,
  _swigc__p_FIX__EncodedListStatusText,
  _swigc__p_FIX__EncodedListStatusTextLen,
  _swigc__p_FIX__EncodedMktSegmDesc,
  _swigc__p_FIX__EncodedMktSegmDescLen,
  _swigc__p_FIX__EncodedSecurityDesc,
  _swigc__p_FIX__EncodedSecurityDescLen,
  _swigc__p_FIX__EncodedSecurityListDesc,
  _swigc__p_FIX__EncodedSecurityListDescLen,
  _swigc__p_FIX__EncodedSubject,
  _swigc__p_FIX__EncodedSubjectLen,
  _swigc__p_FIX__EncodedText,
  _swigc__p_FIX__EncodedTextLen,
  _swigc__p_FIX__EncodedUnderlyingIssuer,
  _swigc__p_FIX__EncodedUnderlyingIssuerLen,
  _swigc__p_FIX__EncodedUnderlyingSecurityDesc,
  _swigc__p_FIX__EncodedUnderlyingSecurityDescLen,
  _swigc__p_FIX__EncryptMethod,
  _swigc__p_FIX__EncryptedNewPassword,
  _swigc__p_FIX__EncryptedNewPasswordLen,
  _swigc__p_FIX__EncryptedPassword,
  _swigc__p_FIX__EncryptedPasswordLen,
  _swigc__p_FIX__EncryptedPasswordMethod,
  _swigc__p_FIX__EndAccruedInterestAmt,
  _swigc__p_FIX__EndCash,
  _swigc__p_FIX__EndDate,
  _swigc__p_FIX__EndMaturityMonthYear,
  _swigc__p_FIX__EndSeqNo,
  _swigc__p_FIX__EndStrikePxRange,
  _swigc__p_FIX__EndTickPriceRange,
  _swigc__p_FIX__EventDate,
  _swigc__p_FIX__EventPx,
  _swigc__p_FIX__EventText,
  _swigc__p_FIX__EventTime,
  _swigc__p_FIX__EventType,
  _swigc__p_FIX__ExDate,
  _swigc__p_FIX__ExDestination,
  _swigc__p_FIX__ExDestinationIDSource,
  _swigc__p_FIX__Exception,
  _swigc__p_FIX__ExchangeForPhysical,
  _swigc__p_FIX__ExchangeRule,
  _swigc__p_FIX__ExchangeSpecialInstructions,
  _swigc__p_FIX__ExecAckStatus,
  _swigc__p_FIX__ExecBroker,
  _swigc__p_FIX__ExecID,
  _swigc__p_FIX__ExecInst,
  _swigc__p_FIX__ExecInstValue,
  _swigc__p_FIX__ExecPriceAdjustment,
  _swigc__p_FIX__ExecPriceType,
  _swigc__p_FIX__ExecRefID,
  _swigc__p_FIX__ExecRestatementReason,
  _swigc__p_FIX__ExecTransType,
  _swigc__p_FIX__ExecType,
  _swigc__p_FIX__ExecValuationPoint,
  _swigc__p_FIX__ExerciseMethod,
  _swigc__p_FIX__ExerciseStyle,
  _swigc__p_FIX__ExpQty,
  _swigc__p_FIX__ExpType,
  _swigc__p_FIX__ExpirationCycle,
  _swigc__p_FIX__ExpirationQtyType,
  _swigc__p_FIX__ExpireDate,
  _swigc__p_FIX__ExpireTime,
  _swigc__p_FIX__FLOAT,
  _swigc__p_FIX__Factor,
  _swigc__p_FIX__FairValue,
  _swigc__p_FIX__FeeMultiplier,
  _swigc__p_FIX__FieldBase,
  _swigc__p_FIX__FieldConvertError,
  _swigc__p_FIX__FieldMap,
  _swigc__p_FIX__FieldMap__Fields__const_iterator,
  _swigc__p_FIX__FieldMap__Groups__const_iterator,
  _swigc__p_FIX__FieldNotFound,
  _swigc__p_FIX__FileLog,
  _swigc__p_FIX__FileLogFactory,
  _swigc__p_FIX__FileStore,
  _swigc__p_FIX__FileStoreFactory,
  _swigc__p_FIX__FillExecID,
  _swigc__p_FIX__FillLiquidityInd,
  _swigc__p_FIX__FillPx,
  _swigc__p_FIX__FillQty,
  _swigc__p_FIX__FinancialStatus,
  _swigc__p_FIX__FirmTradeID,
  _swigc__p_FIX__FirstPx,
  _swigc__p_FIX__FlexProductEligibilityIndicator,
  _swigc__p_FIX__FlexibleIndicator,
  _swigc__p_FIX__FloorPrice,
  _swigc__p_FIX__FlowScheduleType,
  _swigc__p_FIX__ForexReq,
  _swigc__p_FIX__FundRenewWaiv,
  _swigc__p_FIX__FutSettDate,
  _swigc__p_FIX__FutSettDate2,
  _swigc__p_FIX__FuturesValuationMethod,
  _swigc__p_FIX__GTBookingInst,
  _swigc__p_FIX__GapFillFlag,
  _swigc__p_FIX__GrossTradeAmt,
  _swigc__p_FIX__Group,
  _swigc__p_FIX__HaltReasonChar,
  _swigc__p_FIX__HaltReasonInt,
  _swigc__p_FIX__HandlInst,
  _swigc__p_FIX__Header,
  _swigc__p_FIX__Headline,
  _swigc__p_FIX__HeartBtInt,
  _swigc__p_FIX__HighLimitPrice,
  _swigc__p_FIX__HighPx,
  _swigc__p_FIX__HopCompID,
  _swigc__p_FIX__HopRefID,
  _swigc__p_FIX__HopSendingTime,
  _swigc__p_FIX__HostCrossID,
  _swigc__p_FIX__IDSource,
  _swigc__p_FIX__INT,
  _swigc__p_FIX__IOException,
  _swigc__p_FIX__IOIID,
  _swigc__p_FIX__IOINaturalFlag,
  _swigc__p_FIX__IOIOthSvc,
  _swigc__p_FIX__IOIQltyInd,
  _swigc__p_FIX__IOIQty,
  _swigc__p_FIX__IOIQualifier,
  _swigc__p_FIX__IOIRefID,
  _swigc__p_FIX__IOIShares,
  _swigc__p_FIX__IOITransType,
  _swigc__p_FIX__IOIid,
  _swigc__p_FIX__ImpliedMarketIndicator,
  _swigc__p_FIX__InViewOfCommon,
  _swigc__p_FIX__IncTaxInd,
  _swigc__p_FIX__IncorrectDataFormat,
  _swigc__p_FIX__IncorrectMessageStructure,
  _swigc__p_FIX__IncorrectTagValue,
  _swigc__p_FIX__IndividualAllocID,
  _swigc__p_FIX__IndividualAllocRejCode,
  _swigc__p_FIX__IndividualAllocType,
  _swigc__p_FIX__Initiator,
  _swigc__p_FIX__InputSource,
  _swigc__p_FIX__InstrAttribType,
  _swigc__p_FIX__InstrAttribValue,
  _swigc__p_FIX__InstrRegistry,
  _swigc__p_FIX__InstrmtAssignmentMethod,
  _swigc__p_FIX__InstrumentPartyID,
  _swigc__p_FIX__InstrumentPartyIDSource,
  _swigc__p_FIX__InstrumentPartyRole,
  _swigc__p_FIX__InstrumentPartySubID,
  _swigc__p_FIX__InstrumentPartySubIDType,
  _swigc__p_FIX__IntField,
  _swigc__p_FIX__InterestAccrualDate,
  _swigc__p_FIX__InterestAtMaturity,
  _swigc__p_FIX__InvalidMessage,
  _swigc__p_FIX__InvalidMessageType,
  _swigc__p_FIX__InvalidTagNumber,
  _swigc__p_FIX__InvestorCountryOfResidence,
  _swigc__p_FIX__IssueDate,
  _swigc__p_FIX__Issuer,
  _swigc__p_FIX__LANGUAGE,
  _swigc__p_FIX__LENGTH,
  _swigc__p_FIX__LOCALMKTDATE,
  _swigc__p_FIX__LanguageCode,
  _swigc__p_FIX__LastCapacity,
  _swigc__p_FIX__LastForwardPoints,
  _swigc__p_FIX__LastForwardPoints2,
  _swigc__p_FIX__LastFragment,
  _swigc__p_FIX__LastLiquidityInd,
  _swigc__p_FIX__LastMkt,
  _swigc__p_FIX__LastMsgSeqNumProcessed,
  _swigc__p_FIX__LastNetworkResponseID,
  _swigc__p_FIX__LastParPx,
  _swigc__p_FIX__LastPx,
  _swigc__p_FIX__LastQty,
  _swigc__p_FIX__LastRptRequested,
  _swigc__p_FIX__LastShares,
  _swigc__p_FIX__LastSpotRate,
  _swigc__p_FIX__LastSwapPoints,
  _swigc__p_FIX__LastUpdateTime,
  _swigc__p_FIX__LateIndicator,
  _swigc__p_FIX__LeavesQty,
  _swigc__p_FIX__LegAllocAccount,
  _swigc__p_FIX__LegAllocAcctIDSource,
  _swigc__p_FIX__LegAllocID,
  _swigc__p_FIX__LegAllocQty,
  _swigc__p_FIX__LegAllocSettlCurrency,
  _swigc__p_FIX__LegBenchmarkCurveCurrency,
  _swigc__p_FIX__LegBenchmarkCurveName,
  _swigc__p_FIX__LegBenchmarkCurvePoint,
  _swigc__p_FIX__LegBenchmarkPrice,
  _swigc__p_FIX__LegBenchmarkPriceType,
  _swigc__p_FIX__LegBidForwardPoints,
  _swigc__p_FIX__LegBidPx,
  _swigc__p_FIX__LegCFICode,
  _swigc__p_FIX__LegCalculatedCcyLastQty,
  _swigc__p_FIX__LegContractMultiplier,
  _swigc__p_FIX__LegContractMultiplierUnit,
  _swigc__p_FIX__LegContractSettlMonth,
  _swigc__p_FIX__LegCountryOfIssue,
  _swigc__p_FIX__LegCouponPaymentDate,
  _swigc__p_FIX__LegCouponRate,
  _swigc__p_FIX__LegCoveredOrUncovered,
  _swigc__p_FIX__LegCreditRating,
  _swigc__p_FIX__LegCurrency,
  _swigc__p_FIX__LegCurrencyRatio,
  _swigc__p_FIX__LegDatedDate,
  _swigc__p_FIX__LegDividendYield,
  _swigc__p_FIX__LegExecInst,
  _swigc__p_FIX__LegExerciseStyle,
  _swigc__p_FIX__LegFactor,
  _swigc__p_FIX__LegFlowScheduleType,
  _swigc__p_FIX__LegFutSettDate,
  _swigc__p_FIX__LegGrossTradeAmt,
  _swigc__p_FIX__LegIOIQty,
  _swigc__p_FIX__LegIndividualAllocID,
  _swigc__p_FIX__LegInstrRegistry,
  _swigc__p_FIX__LegInterestAccrualDate,
  _swigc__p_FIX__LegIssueDate,
  _swigc__p_FIX__LegIssuer,
  _swigc__p_FIX__LegLastForwardPoints,
  _swigc__p_FIX__LegLastPx,
  _swigc__p_FIX__LegLastQty,
  _swigc__p_FIX__LegLocaleOfIssue,
  _swigc__p_FIX__LegMaturityDate,
  _swigc__p_FIX__LegMaturityMonthYear,
  _swigc__p_FIX__LegMaturityTime,
  _swigc__p_FIX__LegNumber,
  _swigc__p_FIX__LegOfferForwardPoints,
  _swigc__p_FIX__LegOfferPx,
  _swigc__p_FIX__LegOptAttribute,
  _swigc__p_FIX__LegOptionRatio,
  _swigc__p_FIX__LegOrderQty,
  _swigc__p_FIX__LegPool,
  _swigc__p_FIX__LegPositionEffect,
  _swigc__p_FIX__LegPrice,
  _swigc__p_FIX__LegPriceType,
  _swigc__p_FIX__LegPriceUnitOfMeasure,
  _swigc__p_FIX__LegPriceUnitOfMeasureQty,
  _swigc__p_FIX__LegProduct,
  _swigc__p_FIX__LegPutOrCall,
  _swigc__p_FIX__LegQty,
  _swigc__p_FIX__LegRatioQty,
  _swigc__p_FIX__LegRedemptionDate,
  _swigc__p_FIX__LegRefID,
  _swigc__p_FIX__LegRepoCollateralSecurityType,
  _swigc__p_FIX__LegReportID,
  _swigc__p_FIX__LegRepurchaseRate,
  _swigc__p_FIX__LegRepurchaseTerm,
  _swigc__p_FIX__LegSecurityAltID,
  _swigc__p_FIX__LegSecurityAltIDSource,
  _swigc__p_FIX__LegSecurityDesc,
  _swigc__p_FIX__LegSecurityExchange,
  _swigc__p_FIX__LegSecurityID,
  _swigc__p_FIX__LegSecurityIDSource,
  _swigc__p_FIX__LegSecuritySubType,
  _swigc__p_FIX__LegSecurityType,
  _swigc__p_FIX__LegSettlCurrency,
  _swigc__p_FIX__LegSettlDate,
  _swigc__p_FIX__LegSettlType,
  _swigc__p_FIX__LegSettlmntTyp,
  _swigc__p_FIX__LegSide,
  _swigc__p_FIX__LegStateOrProvinceOfIssue,
  _swigc__p_FIX__LegStipulationType,
  _swigc__p_FIX__LegStipulationValue,
  _swigc__p_FIX__LegStrikeCurrency,
  _swigc__p_FIX__LegStrikePrice,
  _swigc__p_FIX__LegSwapType,
  _swigc__p_FIX__LegSymbol,
  _swigc__p_FIX__LegSymbolSfx,
  _swigc__p_FIX__LegTimeUnit,
  _swigc__p_FIX__LegUnitOfMeasure,
  _swigc__p_FIX__LegUnitOfMeasureQty,
  _swigc__p_FIX__LegVolatility,
  _swigc__p_FIX__LegalConfirm,
  _swigc__p_FIX__LinesOfText,
  _swigc__p_FIX__LiquidityIndType,
  _swigc__p_FIX__LiquidityNumSecurities,
  _swigc__p_FIX__LiquidityPctHigh,
  _swigc__p_FIX__LiquidityPctLow,
  _swigc__p_FIX__LiquidityValue,
  _swigc__p_FIX__ListExecInst,
  _swigc__p_FIX__ListExecInstType,
  _swigc__p_FIX__ListID,
  _swigc__p_FIX__ListMethod,
  _swigc__p_FIX__ListName,
  _swigc__p_FIX__ListNoOrds,
  _swigc__p_FIX__ListOrderStatus,
  _swigc__p_FIX__ListRejectReason,
  _swigc__p_FIX__ListSeqNo,
  _swigc__p_FIX__ListStatusText,
  _swigc__p_FIX__ListStatusType,
  _swigc__p_FIX__ListUpdateAction,
  _swigc__p_FIX__LocaleOfIssue,
  _swigc__p_FIX__LocateReqd,
  _swigc__p_FIX__LocationID,
  _swigc__p_FIX__Log,
  _swigc__p_FIX__LogFactory,
  _swigc__p_FIX__LongQty,
  _swigc__p_FIX__LotType,
  _swigc__p_FIX__LowLimitPrice,
  _swigc__p_FIX__LowPx,
  _swigc__p_FIX__MDBookType,
  _swigc__p_FIX__MDEntryBuyer,
  _swigc__p_FIX__MDEntryDate,
  _swigc__p_FIX__MDEntryForwardPoints,
  _swigc__p_FIX__MDEntryID,
  _swigc__p_FIX__MDEntryOriginator,
  _swigc__p_FIX__MDEntryPositionNo,
  _swigc__p_FIX__MDEntryPx,
  _swigc__p_FIX__MDEntryRefID,
  _swigc__p_FIX__MDEntrySeller,
  _swigc__p_FIX__MDEntrySize,
  _swigc__p_FIX__MDEntrySpotRate,
  _swigc__p_FIX__MDEntryTime,
  _swigc__p_FIX__MDEntryType,
  _swigc__p_FIX__MDFeedType,
  _swigc__p_FIX__MDImplicitDelete,
  _swigc__p_FIX__MDMkt,
  _swigc__p_FIX__MDOriginType,
  _swigc__p_FIX__MDPriceLevel,
  _swigc__p_FIX__MDQuoteType,
  _swigc__p_FIX__MDReportID,
  _swigc__p_FIX__MDReqID,
  _swigc__p_FIX__MDReqRejReason,
  _swigc__p_FIX__MDSecSize,
  _swigc__p_FIX__MDSecSizeType,
  _swigc__p_FIX__MDStreamID,
  _swigc__p_FIX__MDSubBookType,
  _swigc__p_FIX__MDUpdateAction,
  _swigc__p_FIX__MDUpdateType,
  _swigc__p_FIX__MONTHYEAR,
  _swigc__p_FIX__MULTIPLECHARVALUE,
  _swigc__p_FIX__MULTIPLESTRINGVALUE,
  _swigc__p_FIX__MULTIPLEVALUESTRING,
  _swigc__p_FIX__MailingDtls,
  _swigc__p_FIX__MailingInst,
  _swigc__p_FIX__ManualOrderIndicator,
  _swigc__p_FIX__MarginExcess,
  _swigc__p_FIX__MarginRatio,
  _swigc__p_FIX__MarketDepth,
  _swigc__p_FIX__MarketID,
  _swigc__p_FIX__MarketReportID,
  _swigc__p_FIX__MarketReqID,
  _swigc__p_FIX__MarketSegmentDesc,
  _swigc__p_FIX__MarketSegmentID,
  _swigc__p_FIX__MarketUpdateAction,
  _swigc__p_FIX__MassActionRejectReason,
  _swigc__p_FIX__MassActionReportID,
  _swigc__p_FIX__MassActionResponse,
  _swigc__p_FIX__MassActionScope,
  _swigc__p_FIX__MassActionType,
  _swigc__p_FIX__MassCancelRejectReason,
  _swigc__p_FIX__MassCancelRequestType,
  _swigc__p_FIX__MassCancelResponse,
  _swigc__p_FIX__MassStatusReqID,
  _swigc__p_FIX__MassStatusReqType,
  _swigc__p_FIX__MatchAlgorithm,
  _swigc__p_FIX__MatchIncrement,
  _swigc__p_FIX__MatchStatus,
  _swigc__p_FIX__MatchType,
  _swigc__p_FIX__MaturityDate,
  _swigc__p_FIX__MaturityDay,
  _swigc__p_FIX__MaturityMonthYear,
  _swigc__p_FIX__MaturityMonthYearFormat,
  _swigc__p_FIX__MaturityMonthYearIncrement,
  _swigc__p_FIX__MaturityMonthYearIncrementUnits,
  _swigc__p_FIX__MaturityNetMoney,
  _swigc__p_FIX__MaturityRuleID,
  _swigc__p_FIX__MaturityTime,
  _swigc__p_FIX__MaxFloor,
  _swigc__p_FIX__MaxMessageSize,
  _swigc__p_FIX__MaxPriceLevels,
  _swigc__p_FIX__MaxPriceVariation,
  _swigc__p_FIX__MaxShow,
  _swigc__p_FIX__MaxTradeVol,
  _swigc__p_FIX__MemoryStore,
  _swigc__p_FIX__MemoryStoreFactory,
  _swigc__p_FIX__Message,
  _swigc__p_FIX__MessageEncoding,
  _swigc__p_FIX__MessageEventSource,
  _swigc__p_FIX__MessageParseError,
  _swigc__p_FIX__MessageStore,
  _swigc__p_FIX__MessageStoreExceptionWrapper,
  _swigc__p_FIX__MessageStoreFactory,
  _swigc__p_FIX__MessageStoreFactoryExceptionWrapper,
  _swigc__p_FIX__MidPx,
  _swigc__p_FIX__MidYield,
  _swigc__p_FIX__MinBidSize,
  _swigc__p_FIX__MinLotSize,
  _swigc__p_FIX__MinOfferSize,
  _swigc__p_FIX__MinPriceIncrement,
  _swigc__p_FIX__MinPriceIncrementAmount,
  _swigc__p_FIX__MinQty,
  _swigc__p_FIX__MinTradeVol,
  _swigc__p_FIX__MiscFeeAmt,
  _swigc__p_FIX__MiscFeeBasis,
  _swigc__p_FIX__MiscFeeCurr,
  _swigc__p_FIX__MiscFeeType,
  _swigc__p_FIX__MktBidPx,
  _swigc__p_FIX__MktOfferPx,
  _swigc__p_FIX__ModelType,
  _swigc__p_FIX__MoneyLaunderingStatus,
  _swigc__p_FIX__MsgDirection,
  _swigc__p_FIX__MsgSeqNum,
  _swigc__p_FIX__MsgType,
  _swigc__p_FIX__MultiLegReportingType,
  _swigc__p_FIX__MultiLegRptTypeReq,
  _swigc__p_FIX__MultilegModel,
  _swigc__p_FIX__MultilegPriceMethod,
  _swigc__p_FIX__NTPositionLimit,
  _swigc__p_FIX__NUMINGROUP,
  _swigc__p_FIX__Nested2PartyID,
  _swigc__p_FIX__Nested2PartyIDSource,
  _swigc__p_FIX__Nested2PartyRole,
  _swigc__p_FIX__Nested2PartySubID,
  _swigc__p_FIX__Nested2PartySubIDType,
  _swigc__p_FIX__Nested3PartyID,
  _swigc__p_FIX__Nested3PartyIDSource,
  _swigc__p_FIX__Nested3PartyRole,
  _swigc__p_FIX__Nested3PartySubID,
  _swigc__p_FIX__Nested3PartySubIDType,
  _swigc__p_FIX__Nested4PartyID,
  _swigc__p_FIX__Nested4PartyIDSource,
  _swigc__p_FIX__Nested4PartyRole,
  _swigc__p_FIX__Nested4PartySubID,
  _swigc__p_FIX__Nested4PartySubIDType,
  _swigc__p_FIX__NestedInstrAttribType,
  _swigc__p_FIX__NestedInstrAttribValue,
  _swigc__p_FIX__NestedPartyID,
  _swigc__p_FIX__NestedPartyIDSource,
  _swigc__p_FIX__NestedPartyRole,
  _swigc__p_FIX__NestedPartySubID,
  _swigc__p_FIX__NestedPartySubIDType,
  _swigc__p_FIX__NetChgPrevDay,
  _swigc__p_FIX__NetGrossInd,
  _swigc__p_FIX__NetMoney,
  _swigc__p_FIX__NetworkRequestID,
  _swigc__p_FIX__NetworkRequestType,
  _swigc__p_FIX__NetworkResponseID,
  _swigc__p_FIX__NetworkStatusResponseType,
  _swigc__p_FIX__NewPassword,
  _swigc__p_FIX__NewSeqNo,
  _swigc__p_FIX__NewsCategory,
  _swigc__p_FIX__NewsID,
  _swigc__p_FIX__NewsRefID,
  _swigc__p_FIX__NewsRefType,
  _swigc__p_FIX__NextExpectedMsgSeqNum,
  _swigc__p_FIX__NoAffectedOrders,
  _swigc__p_FIX__NoAllocs,
  _swigc__p_FIX__NoAltMDSource,
  _swigc__p_FIX__NoApplIDs,
  _swigc__p_FIX__NoAsgnReqs,
  _swigc__p_FIX__NoBidComponents,
  _swigc__p_FIX__NoBidDescriptors,
  _swigc__p_FIX__NoCapacities,
  _swigc__p_FIX__NoClearingInstructions,
  _swigc__p_FIX__NoCollInquiryQualifier,
  _swigc__p_FIX__NoCompIDs,
  _swigc__p_FIX__NoComplexEventDates,
  _swigc__p_FIX__NoComplexEventTimes,
  _swigc__p_FIX__NoComplexEvents,
  _swigc__p_FIX__NoContAmts,
  _swigc__p_FIX__NoContraBrokers,
  _swigc__p_FIX__NoDates,
  _swigc__p_FIX__NoDerivativeEvents,
  _swigc__p_FIX__NoDerivativeInstrAttrib,
  _swigc__p_FIX__NoDerivativeInstrumentParties,
  _swigc__p_FIX__NoDerivativeInstrumentPartySubIDs,
  _swigc__p_FIX__NoDerivativeSecurityAltID,
  _swigc__p_FIX__NoDistribInsts,
  _swigc__p_FIX__NoDlvyInst,
  _swigc__p_FIX__NoEvents,
  _swigc__p_FIX__NoExecInstRules,
  _swigc__p_FIX__NoExecs,
  _swigc__p_FIX__NoExpiration,
  _swigc__p_FIX__NoFills,
  _swigc__p_FIX__NoHops,
  _swigc__p_FIX__NoIOIQualifiers,
  _swigc__p_FIX__NoInstrAttrib,
  _swigc__p_FIX__NoInstrumentParties,
  _swigc__p_FIX__NoInstrumentPartySubIDs,
  _swigc__p_FIX__NoLegAllocs,
  _swigc__p_FIX__NoLegSecurityAltID,
  _swigc__p_FIX__NoLegStipulations,
  _swigc__p_FIX__NoLegs,
  _swigc__p_FIX__NoLinesOfText,
  _swigc__p_FIX__NoLotTypeRules,
  _swigc__p_FIX__NoMDEntries,
  _swigc__p_FIX__NoMDEntryTypes,
  _swigc__p_FIX__NoMDFeedTypes,
  _swigc__p_FIX__NoMarketSegments,
  _swigc__p_FIX__NoMatchRules,
  _swigc__p_FIX__NoMaturityRules,
  _swigc__p_FIX__NoMiscFees,
  _swigc__p_FIX__NoMsgTypes,
  _swigc__p_FIX__NoNested2PartyIDs,
  _swigc__p_FIX__NoNested2PartySubIDs,
  _swigc__p_FIX__NoNested3PartyIDs,
  _swigc__p_FIX__NoNested3PartySubIDs,
  _swigc__p_FIX__NoNested4PartyIDs,
  _swigc__p_FIX__NoNested4PartySubIDs,
  _swigc__p_FIX__NoNestedInstrAttrib,
  _swigc__p_FIX__NoNestedPartyIDs,
  _swigc__p_FIX__NoNestedPartySubIDs,
  _swigc__p_FIX__NoNewsRefIDs,
  _swigc__p_FIX__NoNotAffectedOrders,
  _swigc__p_FIX__NoOfLegUnderlyings,
  _swigc__p_FIX__NoOfSecSizes,
  _swigc__p_FIX__NoOrdTypeRules,
  _swigc__p_FIX__NoOrders,
  _swigc__p_FIX__NoPartyIDs,
  _swigc__p_FIX__NoPartySubIDs,
  _swigc__p_FIX__NoPosAmt,
  _swigc__p_FIX__NoPositions,
  _swigc__p_FIX__NoQuoteEntries,
  _swigc__p_FIX__NoQuoteQualifiers,
  _swigc__p_FIX__NoQuoteSets,
  _swigc__p_FIX__NoRateSources,
  _swigc__p_FIX__NoRegistDtls,
  _swigc__p_FIX__NoRelatedSym,
  _swigc__p_FIX__NoRootPartyIDs,
  _swigc__p_FIX__NoRootPartySubIDs,
  _swigc__p_FIX__NoRoutingIDs,
  _swigc__p_FIX__NoRpts,
  _swigc__p_FIX__NoSecurityAltID,
  _swigc__p_FIX__NoSecurityTypes,
  _swigc__p_FIX__NoSettlDetails,
  _swigc__p_FIX__NoSettlInst,
  _swigc__p_FIX__NoSettlOblig,
  _swigc__p_FIX__NoSettlPartyIDs,
  _swigc__p_FIX__NoSettlPartySubIDs,
  _swigc__p_FIX__NoSideTrdRegTS,
  _swigc__p_FIX__NoSides,
  _swigc__p_FIX__NoStatsIndicators,
  _swigc__p_FIX__NoStipulations,
  _swigc__p_FIX__NoStrategyParameters,
  _swigc__p_FIX__NoStrikeRules,
  _swigc__p_FIX__NoStrikes,
  _swigc__p_FIX__NoTagValue,
  _swigc__p_FIX__NoTargetPartyIDs,
  _swigc__p_FIX__NoTickRules,
  _swigc__p_FIX__NoTimeInForceRules,
  _swigc__p_FIX__NoTrades,
  _swigc__p_FIX__NoTradingSessionRules,
  _swigc__p_FIX__NoTradingSessions,
  _swigc__p_FIX__NoTrdRegTimestamps,
  _swigc__p_FIX__NoTrdRepIndicators,
  _swigc__p_FIX__NoUnderlyingAmounts,
  _swigc__p_FIX__NoUnderlyingLegSecurityAltID,
  _swigc__p_FIX__NoUnderlyingSecurityAltID,
  _swigc__p_FIX__NoUnderlyingStips,
  _swigc__p_FIX__NoUnderlyings,
  _swigc__p_FIX__NoUndlyInstrumentParties,
  _swigc__p_FIX__NoUndlyInstrumentPartySubIDs,
  _swigc__p_FIX__NotAffOrigClOrdID,
  _swigc__p_FIX__NotAffectedOrderID,
  _swigc__p_FIX__NotifyBrokerOfCredit,
  _swigc__p_FIX__NotionalPercentageOutstanding,
  _swigc__p_FIX__NullApplication,
  _swigc__p_FIX__NullLog,
  _swigc__p_FIX__NumBidders,
  _swigc__p_FIX__NumDaysInterest,
  _swigc__p_FIX__NumTickets,
  _swigc__p_FIX__NumberOfOrders,
  _swigc__p_FIX__OddLot,
  _swigc__p_FIX__OfferForwardPoints,
  _swigc__p_FIX__OfferForwardPoints2,
  _swigc__p_FIX__OfferPx,
  _swigc__p_FIX__OfferSize,
  _swigc__p_FIX__OfferSpotRate,
  _swigc__p_FIX__OfferSwapPoints,
  _swigc__p_FIX__OfferYield,
  _swigc__p_FIX__OnBehalfOfCompID,
  _swigc__p_FIX__OnBehalfOfLocationID,
  _swigc__p_FIX__OnBehalfOfSendingTime,
  _swigc__p_FIX__OnBehalfOfSubID,
  _swigc__p_FIX__OpenClose,
  _swigc__p_FIX__OpenCloseSettlFlag,
  _swigc__p_FIX__OpenCloseSettleFlag,
  _swigc__p_FIX__OpenInterest,
  _swigc__p_FIX__OptAttribute,
  _swigc__p_FIX__OptPayAmount,
  _swigc__p_FIX__OptPayoutAmount,
  _swigc__p_FIX__OptPayoutType,
  _swigc__p_FIX__OrdRejReason,
  _swigc__p_FIX__OrdStatus,
  _swigc__p_FIX__OrdStatusReqID,
  _swigc__p_FIX__OrdType,
  _swigc__p_FIX__OrderAvgPx,
  _swigc__p_FIX__OrderBookingQty,
  _swigc__p_FIX__OrderCapacity,
  _swigc__p_FIX__OrderCapacityQty,
  _swigc__p_FIX__OrderCategory,
  _swigc__p_FIX__OrderDelay,
  _swigc__p_FIX__OrderDelayUnit,
  _swigc__p_FIX__OrderHandlingInstSource,
  _swigc__p_FIX__OrderID,
  _swigc__p_FIX__OrderInputDevice,
  _swigc__p_FIX__OrderPercent,
  _swigc__p_FIX__OrderQty,
  _swigc__p_FIX__OrderQty2,
  _swigc__p_FIX__OrderRestrictions,
  _swigc__p_FIX__OrigClOrdID,
  _swigc__p_FIX__OrigCrossID,
  _swigc__p_FIX__OrigCustOrderCapacity,
  _swigc__p_FIX__OrigOrdModTime,
  _swigc__p_FIX__OrigPosReqRefID,
  _swigc__p_FIX__OrigSecondaryTradeID,
  _swigc__p_FIX__OrigSendingTime,
  _swigc__p_FIX__OrigTime,
  _swigc__p_FIX__OrigTradeDate,
  _swigc__p_FIX__OrigTradeHandlingInstr,
  _swigc__p_FIX__OrigTradeID,
  _swigc__p_FIX__OriginalNotionalPercentageOutstanding,
  _swigc__p_FIX__OutMainCntryUIndex,
  _swigc__p_FIX__OutsideIndexPct,
  _swigc__p_FIX__OwnerType,
  _swigc__p_FIX__OwnershipType,
  _swigc__p_FIX__PERCENTAGE,
  _swigc__p_FIX__PRICE,
  _swigc__p_FIX__PRICEOFFSET,
  _swigc__p_FIX__ParentMktSegmID,
  _swigc__p_FIX__ParticipationRate,
  _swigc__p_FIX__PartyID,
  _swigc__p_FIX__PartyIDSource,
  _swigc__p_FIX__PartyRole,
  _swigc__p_FIX__PartySubID,
  _swigc__p_FIX__PartySubIDType,
  _swigc__p_FIX__Password,
  _swigc__p_FIX__PaymentDate,
  _swigc__p_FIX__PaymentMethod,
  _swigc__p_FIX__PaymentRef,
  _swigc__p_FIX__PaymentRemitterID,
  _swigc__p_FIX__PctAtRisk,
  _swigc__p_FIX__PegDifference,
  _swigc__p_FIX__PegLimitType,
  _swigc__p_FIX__PegMoveType,
  _swigc__p_FIX__PegOffsetType,
  _swigc__p_FIX__PegOffsetValue,
  _swigc__p_FIX__PegPriceType,
  _swigc__p_FIX__PegRoundDirection,
  _swigc__p_FIX__PegScope,
  _swigc__p_FIX__PegSecurityDesc,
  _swigc__p_FIX__PegSecurityID,
  _swigc__p_FIX__PegSecurityIDSource,
  _swigc__p_FIX__PegSymbol,
  _swigc__p_FIX__PeggedPrice,
  _swigc__p_FIX__PeggedRefPrice,
  _swigc__p_FIX__Pool,
  _swigc__p_FIX__PosAmt,
  _swigc__p_FIX__PosAmtType,
  _swigc__p_FIX__PosMaintAction,
  _swigc__p_FIX__PosMaintResult,
  _swigc__p_FIX__PosMaintRptID,
  _swigc__p_FIX__PosMaintRptRefID,
  _swigc__p_FIX__PosMaintStatus,
  _swigc__p_FIX__PosQtyStatus,
  _swigc__p_FIX__PosReqID,
  _swigc__p_FIX__PosReqResult,
  _swigc__p_FIX__PosReqStatus,
  _swigc__p_FIX__PosReqType,
  _swigc__p_FIX__PosTransType,
  _swigc__p_FIX__PosType,
  _swigc__p_FIX__PositionCurrency,
  _swigc__p_FIX__PositionEffect,
  _swigc__p_FIX__PositionLimit,
  _swigc__p_FIX__PossDupFlag,
  _swigc__p_FIX__PossResend,
  _swigc__p_FIX__PreTradeAnonymity,
  _swigc__p_FIX__PreallocMethod,
  _swigc__p_FIX__PrevClosePx,
  _swigc__p_FIX__PreviouslyReported,
  _swigc__p_FIX__Price,
  _swigc__p_FIX__Price2,
  _swigc__p_FIX__PriceDelta,
  _swigc__p_FIX__PriceImprovement,
  _swigc__p_FIX__PriceLimitType,
  _swigc__p_FIX__PriceProtectionScope,
  _swigc__p_FIX__PriceQuoteMethod,
  _swigc__p_FIX__PriceType,
  _swigc__p_FIX__PriceUnitOfMeasure,
  _swigc__p_FIX__PriceUnitOfMeasureQty,
  _swigc__p_FIX__PriorSettlPrice,
  _swigc__p_FIX__PriorSpreadIndicator,
  _swigc__p_FIX__PriorityIndicator,
  _swigc__p_FIX__PrivateQuote,
  _swigc__p_FIX__ProcessCode,
  _swigc__p_FIX__Product,
  _swigc__p_FIX__ProductComplex,
  _swigc__p_FIX__ProgPeriodInterval,
  _swigc__p_FIX__ProgRptReqs,
  _swigc__p_FIX__PublishTrdIndicator,
  _swigc__p_FIX__PutOrCall,
  _swigc__p_FIX__QTY,
  _swigc__p_FIX__QtyType,
  _swigc__p_FIX__Quantity,
  _swigc__p_FIX__QuantityDate,
  _swigc__p_FIX__QuantityType,
  _swigc__p_FIX__QuoteAckStatus,
  _swigc__p_FIX__QuoteCancelType,
  _swigc__p_FIX__QuoteCondition,
  _swigc__p_FIX__QuoteEntryID,
  _swigc__p_FIX__QuoteEntryRejectReason,
  _swigc__p_FIX__QuoteEntryStatus,
  _swigc__p_FIX__QuoteID,
  _swigc__p_FIX__QuoteMsgID,
  _swigc__p_FIX__QuotePriceType,
  _swigc__p_FIX__QuoteQualifier,
  _swigc__p_FIX__QuoteRejectReason,
  _swigc__p_FIX__QuoteReqID,
  _swigc__p_FIX__QuoteRequestRejectReason,
  _swigc__p_FIX__QuoteRequestType,
  _swigc__p_FIX__QuoteRespID,
  _swigc__p_FIX__QuoteRespType,
  _swigc__p_FIX__QuoteResponseLevel,
  _swigc__p_FIX__QuoteSetID,
  _swigc__p_FIX__QuoteSetValidUntilTime,
  _swigc__p_FIX__QuoteStatus,
  _swigc__p_FIX__QuoteStatusReqID,
  _swigc__p_FIX__QuoteType,
  _swigc__p_FIX__RFQReqID,
  _swigc__p_FIX__RateSource,
  _swigc__p_FIX__RateSourceType,
  _swigc__p_FIX__RatioQty,
  _swigc__p_FIX__RawData,
  _swigc__p_FIX__RawDataLength,
  _swigc__p_FIX__ReceivedDeptID,
  _swigc__p_FIX__RedemptionDate,
  _swigc__p_FIX__RefAllocID,
  _swigc__p_FIX__RefApplExtID,
  _swigc__p_FIX__RefApplID,
  _swigc__p_FIX__RefApplLastSeqNum,
  _swigc__p_FIX__RefApplReqID,
  _swigc__p_FIX__RefApplVerID,
  _swigc__p_FIX__RefCompID,
  _swigc__p_FIX__RefCstmApplVerID,
  _swigc__p_FIX__RefMsgType,
  _swigc__p_FIX__RefOrdIDReason,
  _swigc__p_FIX__RefOrderID,
  _swigc__p_FIX__RefOrderIDSource,
  _swigc__p_FIX__RefSeqNum,
  _swigc__p_FIX__RefSubID,
  _swigc__p_FIX__RefTagID,
  _swigc__p_FIX__ReferencePage,
  _swigc__p_FIX__RefreshIndicator,
  _swigc__p_FIX__RefreshQty,
  _swigc__p_FIX__RegistAcctType,
  _swigc__p_FIX__RegistDetls,
  _swigc__p_FIX__RegistDtls,
  _swigc__p_FIX__RegistEmail,
  _swigc__p_FIX__RegistID,
  _swigc__p_FIX__RegistRefID,
  _swigc__p_FIX__RegistRejReasonCode,
  _swigc__p_FIX__RegistRejReasonText,
  _swigc__p_FIX__RegistStatus,
  _swigc__p_FIX__RegistTransType,
  _swigc__p_FIX__RejectLogon,
  _swigc__p_FIX__RejectText,
  _swigc__p_FIX__RelSymTransactTime,
  _swigc__p_FIX__RelatdSym,
  _swigc__p_FIX__RepeatedTag,
  _swigc__p_FIX__RepeatingGroupCountMismatch,
  _swigc__p_FIX__RepoCollateralSecurityType,
  _swigc__p_FIX__ReportToExch,
  _swigc__p_FIX__ReportedPx,
  _swigc__p_FIX__ReportedPxDiff,
  _swigc__p_FIX__RepurchaseRate,
  _swigc__p_FIX__RepurchaseTerm,
  _swigc__p_FIX__RequiredTagMissing,
  _swigc__p_FIX__ResetSeqNumFlag,
  _swigc__p_FIX__RespondentType,
  _swigc__p_FIX__ResponseDestination,
  _swigc__p_FIX__ResponseTransportType,
  _swigc__p_FIX__RestructuringType,
  _swigc__p_FIX__ReversalIndicator,
  _swigc__p_FIX__RiskFreeRate,
  _swigc__p_FIX__RndPx,
  _swigc__p_FIX__RootPartyID,
  _swigc__p_FIX__RootPartyIDSource,
  _swigc__p_FIX__RootPartyRole,
  _swigc__p_FIX__RootPartySubID,
  _swigc__p_FIX__RootPartySubIDType,
  _swigc__p_FIX__RoundLot,
  _swigc__p_FIX__RoundingDirection,
  _swigc__p_FIX__RoundingModulus,
  _swigc__p_FIX__RoutingID,
  _swigc__p_FIX__RoutingType,
  _swigc__p_FIX__RptSeq,
  _swigc__p_FIX__RptSys,
  _swigc__p_FIX__Rule80A,
  _swigc__p_FIX__RuntimeError,
  _swigc__p_FIX__SEQNUM,
  _swigc__p_FIX__STRING,
  _swigc__p_FIX__Scope,
  _swigc__p_FIX__ScreenLog,
  _swigc__p_FIX__ScreenLogFactory,
  _swigc__p_FIX__SecondaryAllocID,
  _swigc__p_FIX__SecondaryClOrdID,
  _swigc__p_FIX__SecondaryDisplayQty,
  _swigc__p_FIX__SecondaryExecID,
  _swigc__p_FIX__SecondaryFirmTradeID,
  _swigc__p_FIX__SecondaryHighLimitPrice,
  _swigc__p_FIX__SecondaryIndividualAllocID,
  _swigc__p_FIX__SecondaryLowLimitPrice,
  _swigc__p_FIX__SecondaryOrderID,
  _swigc__p_FIX__SecondaryPriceLimitType,
  _swigc__p_FIX__SecondaryTradeID,
  _swigc__p_FIX__SecondaryTradeReportID,
  _swigc__p_FIX__SecondaryTradeReportRefID,
  _swigc__p_FIX__SecondaryTradingReferencePrice,
  _swigc__p_FIX__SecondaryTrdType,
  _swigc__p_FIX__SecureData,
  _swigc__p_FIX__SecureDataLen,
  _swigc__p_FIX__SecurityAltID,
  _swigc__p_FIX__SecurityAltIDSource,
  _swigc__p_FIX__SecurityDesc,
  _swigc__p_FIX__SecurityExchange,
  _swigc__p_FIX__SecurityGroup,
  _swigc__p_FIX__SecurityID,
  _swigc__p_FIX__SecurityIDSource,
  _swigc__p_FIX__SecurityListDesc,
  _swigc__p_FIX__SecurityListID,
  _swigc__p_FIX__SecurityListRefID,
  _swigc__p_FIX__SecurityListRequestType,
  _swigc__p_FIX__SecurityListType,
  _swigc__p_FIX__SecurityListTypeSource,
  _swigc__p_FIX__SecurityReportID,
  _swigc__p_FIX__SecurityReqID,
  _swigc__p_FIX__SecurityRequestResult,
  _swigc__p_FIX__SecurityRequestType,
  _swigc__p_FIX__SecurityResponseID,
  _swigc__p_FIX__SecurityResponseType,
  _swigc__p_FIX__SecuritySettlAgentAcctName,
  _swigc__p_FIX__SecuritySettlAgentAcctNum,
  _swigc__p_FIX__SecuritySettlAgentCode,
  _swigc__p_FIX__SecuritySettlAgentContactName,
  _swigc__p_FIX__SecuritySettlAgentContactPhone,
  _swigc__p_FIX__SecuritySettlAgentName,
  _swigc__p_FIX__SecurityStatus,
  _swigc__p_FIX__SecurityStatusReqID,
  _swigc__p_FIX__SecuritySubType,
  _swigc__p_FIX__SecurityTradingEvent,
  _swigc__p_FIX__SecurityTradingStatus,
  _swigc__p_FIX__SecurityType,
  _swigc__p_FIX__SecurityUpdateAction,
  _swigc__p_FIX__SecurityXML,
  _swigc__p_FIX__SecurityXMLLen,
  _swigc__p_FIX__SecurityXMLSchema,
  _swigc__p_FIX__SellVolume,
  _swigc__p_FIX__SellerDays,
  _swigc__p_FIX__SenderCompID,
  _swigc__p_FIX__SenderLocationID,
  _swigc__p_FIX__SenderSubID,
  _swigc__p_FIX__SendingDate,
  _swigc__p_FIX__SendingTime,
  _swigc__p_FIX__Seniority,
  _swigc__p_FIX__Session,
  _swigc__p_FIX__SessionID,
  _swigc__p_FIX__SessionNotFound,
  _swigc__p_FIX__SessionRejectReason,
  _swigc__p_FIX__SessionSettings,
  _swigc__p_FIX__SessionStatus,
  _swigc__p_FIX__SettlBrkrCode,
  _swigc__p_FIX__SettlCurrAmt,
  _swigc__p_FIX__SettlCurrBidFxRate,
  _swigc__p_FIX__SettlCurrFxRate,
  _swigc__p_FIX__SettlCurrFxRateCalc,
  _swigc__p_FIX__SettlCurrOfferFxRate,
  _swigc__p_FIX__SettlCurrency,
  _swigc__p_FIX__SettlDate,
  _swigc__p_FIX__SettlDate2,
  _swigc__p_FIX__SettlDeliveryType,
  _swigc__p_FIX__SettlDepositoryCode,
  _swigc__p_FIX__SettlInstCode,
  _swigc__p_FIX__SettlInstID,
  _swigc__p_FIX__SettlInstMode,
  _swigc__p_FIX__SettlInstMsgID,
  _swigc__p_FIX__SettlInstRefID,
  _swigc__p_FIX__SettlInstReqID,
  _swigc__p_FIX__SettlInstReqRejCode,
  _swigc__p_FIX__SettlInstSource,
  _swigc__p_FIX__SettlInstTransType,
  _swigc__p_FIX__SettlLocation,
  _swigc__p_FIX__SettlMethod,
  _swigc__p_FIX__SettlObligID,
  _swigc__p_FIX__SettlObligMode,
  _swigc__p_FIX__SettlObligMsgID,
  _swigc__p_FIX__SettlObligRefID,
  _swigc__p_FIX__SettlObligSource,
  _swigc__p_FIX__SettlObligTransType,
  _swigc__p_FIX__SettlPartyID,
  _swigc__p_FIX__SettlPartyIDSource,
  _swigc__p_FIX__SettlPartyRole,
  _swigc__p_FIX__SettlPartySubID,
  _swigc__p_FIX__SettlPartySubIDType,
  _swigc__p_FIX__SettlPrice,
  _swigc__p_FIX__SettlPriceType,
  _swigc__p_FIX__SettlSessID,
  _swigc__p_FIX__SettlSessSubID,
  _swigc__p_FIX__SettlType,
  _swigc__p_FIX__SettleOnOpenFlag,
  _swigc__p_FIX__SettlementCycleNo,
  _swigc__p_FIX__SettlmntTyp,
  _swigc__p_FIX__SharedCommission,
  _swigc__p_FIX__Shares,
  _swigc__p_FIX__ShortQty,
  _swigc__p_FIX__ShortSaleReason,
  _swigc__p_FIX__Side,
  _swigc__p_FIX__SideComplianceID,
  _swigc__p_FIX__SideCurrency,
  _swigc__p_FIX__SideExecID,
  _swigc__p_FIX__SideFillStationCd,
  _swigc__p_FIX__SideGrossTradeAmt,
  _swigc__p_FIX__SideLastQty,
  _swigc__p_FIX__SideLiquidityInd,
  _swigc__p_FIX__SideMultiLegReportingType,
  _swigc__p_FIX__SideQty,
  _swigc__p_FIX__SideReasonCd,
  _swigc__p_FIX__SideSettlCurrency,
  _swigc__p_FIX__SideTimeInForce,
  _swigc__p_FIX__SideTradeReportID,
  _swigc__p_FIX__SideTrdRegTimestamp,
  _swigc__p_FIX__SideTrdRegTimestampSrc,
  _swigc__p_FIX__SideTrdRegTimestampType,
  _swigc__p_FIX__SideTrdSubTyp,
  _swigc__p_FIX__SideValue1,
  _swigc__p_FIX__SideValue2,
  _swigc__p_FIX__SideValueInd,
  _swigc__p_FIX__Signature,
  _swigc__p_FIX__SignatureLength,
  _swigc__p_FIX__SocketAcceptor,
  _swigc__p_FIX__SocketCloseFailed,
  _swigc__p_FIX__SocketException,
  _swigc__p_FIX__SocketInitiator,
  _swigc__p_FIX__SocketRecvFailed,
  _swigc__p_FIX__SocketSendFailed,
  _swigc__p_FIX__SolicitedFlag,
  _swigc__p_FIX__Spread,
  _swigc__p_FIX__SpreadToBenchmark,
  _swigc__p_FIX__StandInstDbID,
  _swigc__p_FIX__StandInstDbName,
  _swigc__p_FIX__StandInstDbType,
  _swigc__p_FIX__StartCash,
  _swigc__p_FIX__StartDate,
  _swigc__p_FIX__StartMaturityMonthYear,
  _swigc__p_FIX__StartStrikePxRange,
  _swigc__p_FIX__StartTickPriceRange,
  _swigc__p_FIX__StateOrProvinceOfIssue,
  _swigc__p_FIX__StatsType,
  _swigc__p_FIX__StatusText,
  _swigc__p_FIX__StatusValue,
  _swigc__p_FIX__StipulationType,
  _swigc__p_FIX__StipulationValue,
  _swigc__p_FIX__StopPx,
  _swigc__p_FIX__StrategyParameterName,
  _swigc__p_FIX__StrategyParameterType,
  _swigc__p_FIX__StrategyParameterValue,
  _swigc__p_FIX__StreamAsgnAckType,
  _swigc__p_FIX__StreamAsgnRejReason,
  _swigc__p_FIX__StreamAsgnReqID,
  _swigc__p_FIX__StreamAsgnReqType,
  _swigc__p_FIX__StreamAsgnRptID,
  _swigc__p_FIX__StreamAsgnType,
  _swigc__p_FIX__StrikeCurrency,
  _swigc__p_FIX__StrikeExerciseStyle,
  _swigc__p_FIX__StrikeIncrement,
  _swigc__p_FIX__StrikeMultiplier,
  _swigc__p_FIX__StrikePrice,
  _swigc__p_FIX__StrikePriceBoundaryMethod,
  _swigc__p_FIX__StrikePriceBoundaryPrecision,
  _swigc__p_FIX__StrikePriceDeterminationMethod,
  _swigc__p_FIX__StrikeRuleID,
  _swigc__p_FIX__StrikeTime,
  _swigc__p_FIX__StrikeValue,
  _swigc__p_FIX__StringField,
  _swigc__p_FIX__Subject,
  _swigc__p_FIX__SubscriptionRequestType,
  _swigc__p_FIX__SwapPoints,
  _swigc__p_FIX__Symbol,
  _swigc__p_FIX__SymbolSfx,
  _swigc__p_FIX__SynchronizedApplication,
  _swigc__p_FIX__TYPE__Type,
  _swigc__p_FIX__TZTIMEONLY,
  _swigc__p_FIX__TZTIMESTAMP,
  _swigc__p_FIX__TZTransactTime,
  _swigc__p_FIX__TagNotDefinedForMessage,
  _swigc__p_FIX__TagOutOfOrder,
  _swigc__p_FIX__TargetCompID,
  _swigc__p_FIX__TargetLocationID,
  _swigc__p_FIX__TargetPartyID,
  _swigc__p_FIX__TargetPartyIDSource,
  _swigc__p_FIX__TargetPartyRole,
  _swigc__p_FIX__TargetStrategy,
  _swigc__p_FIX__TargetStrategyParameters,
  _swigc__p_FIX__TargetStrategyPerformance,
  _swigc__p_FIX__TargetSubID,
  _swigc__p_FIX__TaxAdvantageType,
  _swigc__p_FIX__TerminationType,
  _swigc__p_FIX__TestMessageIndicator,
  _swigc__p_FIX__TestReqID,
  _swigc__p_FIX__Text,
  _swigc__p_FIX__ThresholdAmount,
  _swigc__p_FIX__TickDirection,
  _swigc__p_FIX__TickIncrement,
  _swigc__p_FIX__TickRuleType,
  _swigc__p_FIX__TierCode,
  _swigc__p_FIX__TimeBracket,
  _swigc__p_FIX__TimeInForce,
  _swigc__p_FIX__TimeToExpiration,
  _swigc__p_FIX__TimeUnit,
  _swigc__p_FIX__TotNoAccQuotes,
  _swigc__p_FIX__TotNoAllocs,
  _swigc__p_FIX__TotNoCxldQuotes,
  _swigc__p_FIX__TotNoFills,
  _swigc__p_FIX__TotNoOrders,
  _swigc__p_FIX__TotNoQuoteEntries,
  _swigc__p_FIX__TotNoRejQuotes,
  _swigc__p_FIX__TotNoRelatedSym,
  _swigc__p_FIX__TotNoSecurityTypes,
  _swigc__p_FIX__TotNoStrikes,
  _swigc__p_FIX__TotNumAssignmentReports,
  _swigc__p_FIX__TotNumReports,
  _swigc__p_FIX__TotNumTradeReports,
  _swigc__p_FIX__TotQuoteEntries,
  _swigc__p_FIX__TotalAccruedInterestAmt,
  _swigc__p_FIX__TotalAffectedOrders,
  _swigc__p_FIX__TotalNetValue,
  _swigc__p_FIX__TotalNumPosReports,
  _swigc__p_FIX__TotalNumSecurities,
  _swigc__p_FIX__TotalNumSecurityTypes,
  _swigc__p_FIX__TotalTakedown,
  _swigc__p_FIX__TotalVolumeTraded,
  _swigc__p_FIX__TotalVolumeTradedDate,
  _swigc__p_FIX__TotalVolumeTradedTime,
  _swigc__p_FIX__TradSesCloseTime,
  _swigc__p_FIX__TradSesEndTime,
  _swigc__p_FIX__TradSesEvent,
  _swigc__p_FIX__TradSesMethod,
  _swigc__p_FIX__TradSesMode,
  _swigc__p_FIX__TradSesOpenTime,
  _swigc__p_FIX__TradSesPreCloseTime,
  _swigc__p_FIX__TradSesReqID,
  _swigc__p_FIX__TradSesStartTime,
  _swigc__p_FIX__TradSesStatus,
  _swigc__p_FIX__TradSesStatusRejReason,
  _swigc__p_FIX__TradSesUpdateAction,
  _swigc__p_FIX__TradeAllocIndicator,
  _swigc__p_FIX__TradeCondition,
  _swigc__p_FIX__TradeDate,
  _swigc__p_FIX__TradeHandlingInstr,
  _swigc__p_FIX__TradeID,
  _swigc__p_FIX__TradeInputDevice,
  _swigc__p_FIX__TradeInputSource,
  _swigc__p_FIX__TradeLegRefID,
  _swigc__p_FIX__TradeLinkID,
  _swigc__p_FIX__TradeOriginationDate,
  _swigc__p_FIX__TradePublishIndicator,
  _swigc__p_FIX__TradeReportID,
  _swigc__p_FIX__TradeReportRefID,
  _swigc__p_FIX__TradeReportRejectReason,
  _swigc__p_FIX__TradeReportTransType,
  _swigc__p_FIX__TradeReportType,
  _swigc__p_FIX__TradeRequestID,
  _swigc__p_FIX__TradeRequestResult,
  _swigc__p_FIX__TradeRequestStatus,
  _swigc__p_FIX__TradeRequestType,
  _swigc__p_FIX__TradeType,
  _swigc__p_FIX__TradeVolume,
  _swigc__p_FIX__TradedFlatSwitch,
  _swigc__p_FIX__TradingCurrency,
  _swigc__p_FIX__TradingReferencePrice,
  _swigc__p_FIX__TradingSessionDesc,
  _swigc__p_FIX__TradingSessionID,
  _swigc__p_FIX__TradingSessionSubID,
  _swigc__p_FIX__Trailer,
  _swigc__p_FIX__TransBkdTime,
  _swigc__p_FIX__TransactTime,
  _swigc__p_FIX__TransferReason,
  _swigc__p_FIX__TrdMatchID,
  _swigc__p_FIX__TrdRegTimestamp,
  _swigc__p_FIX__TrdRegTimestampOrigin,
  _swigc__p_FIX__TrdRegTimestampType,
  _swigc__p_FIX__TrdRepIndicator,
  _swigc__p_FIX__TrdRepPartyRole,
  _swigc__p_FIX__TrdRptStatus,
  _swigc__p_FIX__TrdSubType,
  _swigc__p_FIX__TrdType,
  _swigc__p_FIX__TriggerAction,
  _swigc__p_FIX__TriggerNewPrice,
  _swigc__p_FIX__TriggerNewQty,
  _swigc__p_FIX__TriggerOrderType,
  _swigc__p_FIX__TriggerPrice,
  _swigc__p_FIX__TriggerPriceDirection,
  _swigc__p_FIX__TriggerPriceType,
  _swigc__p_FIX__TriggerPriceTypeScope,
  _swigc__p_FIX__TriggerSecurityDesc,
  _swigc__p_FIX__TriggerSecurityID,
  _swigc__p_FIX__TriggerSecurityIDSource,
  _swigc__p_FIX__TriggerSymbol,
  _swigc__p_FIX__TriggerTradingSessionID,
  _swigc__p_FIX__TriggerTradingSessionSubID,
  _swigc__p_FIX__TriggerType,
  _swigc__p_FIX__URLLink,
  _swigc__p_FIX__UTCDATE,
  _swigc__p_FIX__UTCDATEONLY,
  _swigc__p_FIX__UTCTIMEONLY,
  _swigc__p_FIX__UTCTIMESTAMP,
  _swigc__p_FIX__UnderlyingAdjustedQuantity,
  _swigc__p_FIX__UnderlyingAllocationPercent,
  _swigc__p_FIX__UnderlyingAttachmentPoint,
  _swigc__p_FIX__UnderlyingCFICode,
  _swigc__p_FIX__UnderlyingCPProgram,
  _swigc__p_FIX__UnderlyingCPRegType,
  _swigc__p_FIX__UnderlyingCapValue,
  _swigc__p_FIX__UnderlyingCashAmount,
  _swigc__p_FIX__UnderlyingCashType,
  _swigc__p_FIX__UnderlyingCollectAmount,
  _swigc__p_FIX__UnderlyingContractMultiplier,
  _swigc__p_FIX__UnderlyingContractMultiplierUnit,
  _swigc__p_FIX__UnderlyingCountryOfIssue,
  _swigc__p_FIX__UnderlyingCouponPaymentDate,
  _swigc__p_FIX__UnderlyingCouponRate,
  _swigc__p_FIX__UnderlyingCreditRating,
  _swigc__p_FIX__UnderlyingCurrency,
  _swigc__p_FIX__UnderlyingCurrentValue,
  _swigc__p_FIX__UnderlyingDeliveryAmount,
  _swigc__p_FIX__UnderlyingDetachmentPoint,
  _swigc__p_FIX__UnderlyingDirtyPrice,
  _swigc__p_FIX__UnderlyingEndPrice,
  _swigc__p_FIX__UnderlyingEndValue,
  _swigc__p_FIX__UnderlyingExerciseStyle,
  _swigc__p_FIX__UnderlyingFXRate,
  _swigc__p_FIX__UnderlyingFXRateCalc,
  _swigc__p_FIX__UnderlyingFactor,
  _swigc__p_FIX__UnderlyingFlowScheduleType,
  _swigc__p_FIX__UnderlyingIDSource,
  _swigc__p_FIX__UnderlyingInstrRegistry,
  _swigc__p_FIX__UnderlyingInstrumentPartyID,
  _swigc__p_FIX__UnderlyingInstrumentPartyIDSource,
  _swigc__p_FIX__UnderlyingInstrumentPartyRole,
  _swigc__p_FIX__UnderlyingInstrumentPartySubID,
  _swigc__p_FIX__UnderlyingInstrumentPartySubIDType,
  _swigc__p_FIX__UnderlyingIssueDate,
  _swigc__p_FIX__UnderlyingIssuer,
  _swigc__p_FIX__UnderlyingLastPx,
  _swigc__p_FIX__UnderlyingLastQty,
  _swigc__p_FIX__UnderlyingLegCFICode,
  _swigc__p_FIX__UnderlyingLegMaturityDate,
  _swigc__p_FIX__UnderlyingLegMaturityMonthYear,
  _swigc__p_FIX__UnderlyingLegMaturityTime,
  _swigc__p_FIX__UnderlyingLegOptAttribute,
  _swigc__p_FIX__UnderlyingLegPutOrCall,
  _swigc__p_FIX__UnderlyingLegSecurityAltID,
  _swigc__p_FIX__UnderlyingLegSecurityAltIDSource,
  _swigc__p_FIX__UnderlyingLegSecurityDesc,
  _swigc__p_FIX__UnderlyingLegSecurityExchange,
  _swigc__p_FIX__UnderlyingLegSecurityID,
  _swigc__p_FIX__UnderlyingLegSecurityIDSource,
  _swigc__p_FIX__UnderlyingLegSecuritySubType,
  _swigc__p_FIX__UnderlyingLegSecurityType,
  _swigc__p_FIX__UnderlyingLegStrikePrice,
  _swigc__p_FIX__UnderlyingLegSymbol,
  _swigc__p_FIX__UnderlyingLegSymbolSfx,
  _swigc__p_FIX__UnderlyingLocaleOfIssue,
  _swigc__p_FIX__UnderlyingMaturityDate,
  _swigc__p_FIX__UnderlyingMaturityDay,
  _swigc__p_FIX__UnderlyingMaturityMonthYear,
  _swigc__p_FIX__UnderlyingMaturityTime,
  _swigc__p_FIX__UnderlyingNotionalPercentageOutstanding,
  _swigc__p_FIX__UnderlyingOptAttribute,
  _swigc__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding,
  _swigc__p_FIX__UnderlyingPayAmount,
  _swigc__p_FIX__UnderlyingPriceDeterminationMethod,
  _swigc__p_FIX__UnderlyingPriceUnitOfMeasure,
  _swigc__p_FIX__UnderlyingPriceUnitOfMeasureQty,
  _swigc__p_FIX__UnderlyingProduct,
  _swigc__p_FIX__UnderlyingPutOrCall,
  _swigc__p_FIX__UnderlyingPx,
  _swigc__p_FIX__UnderlyingQty,
  _swigc__p_FIX__UnderlyingRedemptionDate,
  _swigc__p_FIX__UnderlyingRepoCollateralSecurityType,
  _swigc__p_FIX__UnderlyingRepurchaseRate,
  _swigc__p_FIX__UnderlyingRepurchaseTerm,
  _swigc__p_FIX__UnderlyingRestructuringType,
  _swigc__p_FIX__UnderlyingSecurityAltID,
  _swigc__p_FIX__UnderlyingSecurityAltIDSource,
  _swigc__p_FIX__UnderlyingSecurityDesc,
  _swigc__p_FIX__UnderlyingSecurityExchange,
  _swigc__p_FIX__UnderlyingSecurityID,
  _swigc__p_FIX__UnderlyingSecurityIDSource,
  _swigc__p_FIX__UnderlyingSecuritySubType,
  _swigc__p_FIX__UnderlyingSecurityType,
  _swigc__p_FIX__UnderlyingSeniority,
  _swigc__p_FIX__UnderlyingSettlMethod,
  _swigc__p_FIX__UnderlyingSettlPrice,
  _swigc__p_FIX__UnderlyingSettlPriceType,
  _swigc__p_FIX__UnderlyingSettlementDate,
  _swigc__p_FIX__UnderlyingSettlementStatus,
  _swigc__p_FIX__UnderlyingSettlementType,
  _swigc__p_FIX__UnderlyingStartValue,
  _swigc__p_FIX__UnderlyingStateOrProvinceOfIssue,
  _swigc__p_FIX__UnderlyingStipType,
  _swigc__p_FIX__UnderlyingStipValue,
  _swigc__p_FIX__UnderlyingStrikeCurrency,
  _swigc__p_FIX__UnderlyingStrikePrice,
  _swigc__p_FIX__UnderlyingSymbol,
  _swigc__p_FIX__UnderlyingSymbolSfx,
  _swigc__p_FIX__UnderlyingTimeUnit,
  _swigc__p_FIX__UnderlyingTradingSessionID,
  _swigc__p_FIX__UnderlyingTradingSessionSubID,
  _swigc__p_FIX__UnderlyingUnitOfMeasure,
  _swigc__p_FIX__UnderlyingUnitOfMeasureQty,
  _swigc__p_FIX__UndlyInstrumentPartyID,
  _swigc__p_FIX__UndlyInstrumentPartyIDSource,
  _swigc__p_FIX__UndlyInstrumentPartyRole,
  _swigc__p_FIX__UndlyInstrumentPartySubID,
  _swigc__p_FIX__UndlyInstrumentPartySubIDType,
  _swigc__p_FIX__UnitOfMeasure,
  _swigc__p_FIX__UnitOfMeasureQty,
  _swigc__p_FIX__UnsolicitedIndicator,
  _swigc__p_FIX__UnsupportedMessageType,
  _swigc__p_FIX__UnsupportedVersion,
  _swigc__p_FIX__Urgency,
  _swigc__p_FIX__UserRequestID,
  _swigc__p_FIX__UserRequestType,
  _swigc__p_FIX__UserStatus,
  _swigc__p_FIX__UserStatusText,
  _swigc__p_FIX__Username,
  _swigc__p_FIX__UtcDateField,
  _swigc__p_FIX__UtcTimeOnlyField,
  _swigc__p_FIX__UtcTimeStampField,
  _swigc__p_FIX__ValidUntilTime,
  _swigc__p_FIX__ValuationMethod,
  _swigc__p_FIX__ValueOfFutures,
  _swigc__p_FIX__VenueType,
  _swigc__p_FIX__Volatility,
  _swigc__p_FIX__WaveNo,
  _swigc__p_FIX__WorkingIndicator,
  _swigc__p_FIX__WtAverageLiquidity,
  _swigc__p_FIX__XMLDATA,
  _swigc__p_FIX__XmlData,
  _swigc__p_FIX__XmlDataLen,
  _swigc__p_FIX__Yield,
  _swigc__p_FIX__YieldCalcDate,
  _swigc__p_FIX__YieldRedemptionDate,
  _swigc__p_FIX__YieldRedemptionPrice,
  _swigc__p_FIX__YieldRedemptionPriceType,
  _swigc__p_FIX__YieldType,
  _swigc__p_Fields,
  _swigc__p_Group,
  _swigc__p_Groups,
  _swigc__p_IntArray,
  _swigc__p_IntField,
  _swigc__p_Log,
  _swigc__p_LogFactory,
  _swigc__p_MessageStore,
  _swigc__p_MessageStoreFactory,
  _swigc__p_MsgType,
  _swigc__p_Mutex,
  _swigc__p_Responder,
  _swigc__p_SessionID,
  _swigc__p_StringField,
  _swigc__p_TimeRange,
  _swigc__p_UtcDate,
  _swigc__p_UtcDateField,
  _swigc__p_UtcTimeOnly,
  _swigc__p_UtcTimeStamp,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_const_iterator,
  _swigc__p_g_const_iterator,
  _swigc__p_g_iterator,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_message_order,
  _swigc__p_p_FIX__DataDictionary,
  _swigc__p_std__istream,
  _swigc__p_std__ostream,
  _swigc__p_std__setT_FIX__SessionID_t,
  _swigc__p_std__string,
  _swigc__p_std__string__size_type,
  _swigc__p_std__vectorT_std__string_t,
};


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

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic 
 * memory is used. Also, since swig_type_info structures store pointers to 
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization. 
 * The idea is that swig generates all the structures that are needed. 
 * The runtime then collects these partially filled structures. 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned staticly to an initial 
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it 
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded. 
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the 
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int found, init;

  clientdata = clientdata;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }

  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* When multiple interpeters are used, a module could have already been initialized in
     a different interpreter, but not yet have a pointer in this interpreter.
     In this case, we do not want to continue adding types... everything should be
     set up already */
  if (init == 0) return;

  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
  
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif

    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
	type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }

    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
    
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
	if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
	  cast->type = ret;
	  ret = 0;
	} else {
	  /* Check for casting already in the list */
	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
	  if (!ocast) ret = 0;
	}
      }

      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;

#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
  printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;

  if (init_run) return;
  init_run = 1;

  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

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

/*

*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void Init_quickfix(void) {
  size_t i;
  
  SWIG_InitRuntime();
  mQuickfix = rb_define_module("Quickfix");
  
  SWIG_InitializeModule(0);
  for (i = 0; i < swig_module.size; i++) {
    SWIG_define_class(swig_module.types[i]);
  }
  
  SWIG_RubyInitializeTrackings();
  
  SwigClassIntArray.klass = rb_define_class_under(mQuickfix, "IntArray", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_IntArray, (void *) &SwigClassIntArray);
  rb_define_alloc_func(SwigClassIntArray.klass, _wrap_IntArray_allocate);
  rb_define_method(SwigClassIntArray.klass, "initialize", VALUEFUNC(_wrap_new_IntArray), -1);
  rb_define_method(SwigClassIntArray.klass, "[]", VALUEFUNC(_wrap_IntArray___getitem__), -1);
  rb_define_method(SwigClassIntArray.klass, "[]=", VALUEFUNC(_wrap_IntArray___setitem__), -1);
  rb_define_method(SwigClassIntArray.klass, "cast", VALUEFUNC(_wrap_IntArray_cast), -1);
  rb_define_singleton_method(SwigClassIntArray.klass, "frompointer", VALUEFUNC(_wrap_IntArray_frompointer), -1);
  SwigClassIntArray.mark = 0;
  SwigClassIntArray.destroy = (void (*)(void *)) free_IntArray;
  SwigClassIntArray.trackObjects = 0;
  
  SwigClassException.klass = rb_define_class_under(mQuickfix, "Exception", rb_eRuntimeError);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Exception, (void *) &SwigClassException);
  rb_define_alloc_func(SwigClassException.klass, _wrap_Exception_allocate);
  rb_define_method(SwigClassException.klass, "initialize", VALUEFUNC(_wrap_new_Exception), -1);
  rb_define_method(SwigClassException.klass, "type=", VALUEFUNC(_wrap_Exception_type_set), -1);
  rb_define_method(SwigClassException.klass, "type", VALUEFUNC(_wrap_Exception_type_get), -1);
  rb_define_method(SwigClassException.klass, "detail=", VALUEFUNC(_wrap_Exception_detail_set), -1);
  rb_define_method(SwigClassException.klass, "detail", VALUEFUNC(_wrap_Exception_detail_get), -1);
  rb_define_method(SwigClassException.klass, "to_s", VALUEFUNC(_wrap_Exception___str__), -1);
  SwigClassException.mark = 0;
  SwigClassException.destroy = (void (*)(void *)) free_FIX_Exception;
  SwigClassException.trackObjects = 0;
  
  SwigClassDataDictionaryNotFound.klass = rb_define_class_under(mQuickfix, "DataDictionaryNotFound", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DataDictionaryNotFound, (void *) &SwigClassDataDictionaryNotFound);
  rb_define_alloc_func(SwigClassDataDictionaryNotFound.klass, _wrap_DataDictionaryNotFound_allocate);
  rb_define_method(SwigClassDataDictionaryNotFound.klass, "initialize", VALUEFUNC(_wrap_new_DataDictionaryNotFound), -1);
  rb_define_method(SwigClassDataDictionaryNotFound.klass, "version=", VALUEFUNC(_wrap_DataDictionaryNotFound_version_set), -1);
  rb_define_method(SwigClassDataDictionaryNotFound.klass, "version", VALUEFUNC(_wrap_DataDictionaryNotFound_version_get), -1);
  SwigClassDataDictionaryNotFound.mark = 0;
  SwigClassDataDictionaryNotFound.destroy = (void (*)(void *)) free_FIX_DataDictionaryNotFound;
  SwigClassDataDictionaryNotFound.trackObjects = 0;
  
  SwigClassFieldNotFound.klass = rb_define_class_under(mQuickfix, "FieldNotFound", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldNotFound, (void *) &SwigClassFieldNotFound);
  rb_define_alloc_func(SwigClassFieldNotFound.klass, _wrap_FieldNotFound_allocate);
  rb_define_method(SwigClassFieldNotFound.klass, "initialize", VALUEFUNC(_wrap_new_FieldNotFound), -1);
  rb_define_method(SwigClassFieldNotFound.klass, "field=", VALUEFUNC(_wrap_FieldNotFound_field_set), -1);
  rb_define_method(SwigClassFieldNotFound.klass, "field", VALUEFUNC(_wrap_FieldNotFound_field_get), -1);
  SwigClassFieldNotFound.mark = 0;
  SwigClassFieldNotFound.destroy = (void (*)(void *)) free_FIX_FieldNotFound;
  SwigClassFieldNotFound.trackObjects = 0;
  
  SwigClassFieldConvertError.klass = rb_define_class_under(mQuickfix, "FieldConvertError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldConvertError, (void *) &SwigClassFieldConvertError);
  rb_define_alloc_func(SwigClassFieldConvertError.klass, _wrap_FieldConvertError_allocate);
  rb_define_method(SwigClassFieldConvertError.klass, "initialize", VALUEFUNC(_wrap_new_FieldConvertError), -1);
  SwigClassFieldConvertError.mark = 0;
  SwigClassFieldConvertError.destroy = (void (*)(void *)) free_FIX_FieldConvertError;
  SwigClassFieldConvertError.trackObjects = 0;
  
  SwigClassMessageParseError.klass = rb_define_class_under(mQuickfix, "MessageParseError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageParseError, (void *) &SwigClassMessageParseError);
  rb_define_alloc_func(SwigClassMessageParseError.klass, _wrap_MessageParseError_allocate);
  rb_define_method(SwigClassMessageParseError.klass, "initialize", VALUEFUNC(_wrap_new_MessageParseError), -1);
  SwigClassMessageParseError.mark = 0;
  SwigClassMessageParseError.destroy = (void (*)(void *)) free_FIX_MessageParseError;
  SwigClassMessageParseError.trackObjects = 0;
  
  SwigClassInvalidMessage.klass = rb_define_class_under(mQuickfix, "InvalidMessage", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvalidMessage, (void *) &SwigClassInvalidMessage);
  rb_define_alloc_func(SwigClassInvalidMessage.klass, _wrap_InvalidMessage_allocate);
  rb_define_method(SwigClassInvalidMessage.klass, "initialize", VALUEFUNC(_wrap_new_InvalidMessage), -1);
  SwigClassInvalidMessage.mark = 0;
  SwigClassInvalidMessage.destroy = (void (*)(void *)) free_FIX_InvalidMessage;
  SwigClassInvalidMessage.trackObjects = 0;
  
  SwigClassConfigError.klass = rb_define_class_under(mQuickfix, "ConfigError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfigError, (void *) &SwigClassConfigError);
  rb_define_alloc_func(SwigClassConfigError.klass, _wrap_ConfigError_allocate);
  rb_define_method(SwigClassConfigError.klass, "initialize", VALUEFUNC(_wrap_new_ConfigError), -1);
  SwigClassConfigError.mark = 0;
  SwigClassConfigError.destroy = (void (*)(void *)) free_FIX_ConfigError;
  SwigClassConfigError.trackObjects = 0;
  
  SwigClassRuntimeError.klass = rb_define_class_under(mQuickfix, "RuntimeError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RuntimeError, (void *) &SwigClassRuntimeError);
  rb_define_alloc_func(SwigClassRuntimeError.klass, _wrap_RuntimeError_allocate);
  rb_define_method(SwigClassRuntimeError.klass, "initialize", VALUEFUNC(_wrap_new_RuntimeError), -1);
  SwigClassRuntimeError.mark = 0;
  SwigClassRuntimeError.destroy = (void (*)(void *)) free_FIX_RuntimeError;
  SwigClassRuntimeError.trackObjects = 0;
  
  SwigClassInvalidTagNumber.klass = rb_define_class_under(mQuickfix, "InvalidTagNumber", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvalidTagNumber, (void *) &SwigClassInvalidTagNumber);
  rb_define_alloc_func(SwigClassInvalidTagNumber.klass, _wrap_InvalidTagNumber_allocate);
  rb_define_method(SwigClassInvalidTagNumber.klass, "initialize", VALUEFUNC(_wrap_new_InvalidTagNumber), -1);
  rb_define_method(SwigClassInvalidTagNumber.klass, "field=", VALUEFUNC(_wrap_InvalidTagNumber_field_set), -1);
  rb_define_method(SwigClassInvalidTagNumber.klass, "field", VALUEFUNC(_wrap_InvalidTagNumber_field_get), -1);
  SwigClassInvalidTagNumber.mark = 0;
  SwigClassInvalidTagNumber.destroy = (void (*)(void *)) free_FIX_InvalidTagNumber;
  SwigClassInvalidTagNumber.trackObjects = 0;
  
  SwigClassRequiredTagMissing.klass = rb_define_class_under(mQuickfix, "RequiredTagMissing", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RequiredTagMissing, (void *) &SwigClassRequiredTagMissing);
  rb_define_alloc_func(SwigClassRequiredTagMissing.klass, _wrap_RequiredTagMissing_allocate);
  rb_define_method(SwigClassRequiredTagMissing.klass, "initialize", VALUEFUNC(_wrap_new_RequiredTagMissing), -1);
  rb_define_method(SwigClassRequiredTagMissing.klass, "field=", VALUEFUNC(_wrap_RequiredTagMissing_field_set), -1);
  rb_define_method(SwigClassRequiredTagMissing.klass, "field", VALUEFUNC(_wrap_RequiredTagMissing_field_get), -1);
  SwigClassRequiredTagMissing.mark = 0;
  SwigClassRequiredTagMissing.destroy = (void (*)(void *)) free_FIX_RequiredTagMissing;
  SwigClassRequiredTagMissing.trackObjects = 0;
  
  SwigClassTagNotDefinedForMessage.klass = rb_define_class_under(mQuickfix, "TagNotDefinedForMessage", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TagNotDefinedForMessage, (void *) &SwigClassTagNotDefinedForMessage);
  rb_define_alloc_func(SwigClassTagNotDefinedForMessage.klass, _wrap_TagNotDefinedForMessage_allocate);
  rb_define_method(SwigClassTagNotDefinedForMessage.klass, "initialize", VALUEFUNC(_wrap_new_TagNotDefinedForMessage), -1);
  rb_define_method(SwigClassTagNotDefinedForMessage.klass, "field=", VALUEFUNC(_wrap_TagNotDefinedForMessage_field_set), -1);
  rb_define_method(SwigClassTagNotDefinedForMessage.klass, "field", VALUEFUNC(_wrap_TagNotDefinedForMessage_field_get), -1);
  SwigClassTagNotDefinedForMessage.mark = 0;
  SwigClassTagNotDefinedForMessage.destroy = (void (*)(void *)) free_FIX_TagNotDefinedForMessage;
  SwigClassTagNotDefinedForMessage.trackObjects = 0;
  
  SwigClassNoTagValue.klass = rb_define_class_under(mQuickfix, "NoTagValue", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTagValue, (void *) &SwigClassNoTagValue);
  rb_define_alloc_func(SwigClassNoTagValue.klass, _wrap_NoTagValue_allocate);
  rb_define_method(SwigClassNoTagValue.klass, "initialize", VALUEFUNC(_wrap_new_NoTagValue), -1);
  rb_define_method(SwigClassNoTagValue.klass, "field=", VALUEFUNC(_wrap_NoTagValue_field_set), -1);
  rb_define_method(SwigClassNoTagValue.klass, "field", VALUEFUNC(_wrap_NoTagValue_field_get), -1);
  SwigClassNoTagValue.mark = 0;
  SwigClassNoTagValue.destroy = (void (*)(void *)) free_FIX_NoTagValue;
  SwigClassNoTagValue.trackObjects = 0;
  
  SwigClassIncorrectTagValue.klass = rb_define_class_under(mQuickfix, "IncorrectTagValue", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncorrectTagValue, (void *) &SwigClassIncorrectTagValue);
  rb_define_alloc_func(SwigClassIncorrectTagValue.klass, _wrap_IncorrectTagValue_allocate);
  rb_define_method(SwigClassIncorrectTagValue.klass, "initialize", VALUEFUNC(_wrap_new_IncorrectTagValue), -1);
  rb_define_method(SwigClassIncorrectTagValue.klass, "field=", VALUEFUNC(_wrap_IncorrectTagValue_field_set), -1);
  rb_define_method(SwigClassIncorrectTagValue.klass, "field", VALUEFUNC(_wrap_IncorrectTagValue_field_get), -1);
  SwigClassIncorrectTagValue.mark = 0;
  SwigClassIncorrectTagValue.destroy = (void (*)(void *)) free_FIX_IncorrectTagValue;
  SwigClassIncorrectTagValue.trackObjects = 0;
  
  SwigClassIncorrectDataFormat.klass = rb_define_class_under(mQuickfix, "IncorrectDataFormat", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncorrectDataFormat, (void *) &SwigClassIncorrectDataFormat);
  rb_define_alloc_func(SwigClassIncorrectDataFormat.klass, _wrap_IncorrectDataFormat_allocate);
  rb_define_method(SwigClassIncorrectDataFormat.klass, "initialize", VALUEFUNC(_wrap_new_IncorrectDataFormat), -1);
  rb_define_method(SwigClassIncorrectDataFormat.klass, "field=", VALUEFUNC(_wrap_IncorrectDataFormat_field_set), -1);
  rb_define_method(SwigClassIncorrectDataFormat.klass, "field", VALUEFUNC(_wrap_IncorrectDataFormat_field_get), -1);
  SwigClassIncorrectDataFormat.mark = 0;
  SwigClassIncorrectDataFormat.destroy = (void (*)(void *)) free_FIX_IncorrectDataFormat;
  SwigClassIncorrectDataFormat.trackObjects = 0;
  
  SwigClassIncorrectMessageStructure.klass = rb_define_class_under(mQuickfix, "IncorrectMessageStructure", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncorrectMessageStructure, (void *) &SwigClassIncorrectMessageStructure);
  rb_define_alloc_func(SwigClassIncorrectMessageStructure.klass, _wrap_IncorrectMessageStructure_allocate);
  rb_define_method(SwigClassIncorrectMessageStructure.klass, "initialize", VALUEFUNC(_wrap_new_IncorrectMessageStructure), -1);
  SwigClassIncorrectMessageStructure.mark = 0;
  SwigClassIncorrectMessageStructure.destroy = (void (*)(void *)) free_FIX_IncorrectMessageStructure;
  SwigClassIncorrectMessageStructure.trackObjects = 0;
  
  SwigClassDuplicateFieldNumber.klass = rb_define_class_under(mQuickfix, "DuplicateFieldNumber", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DuplicateFieldNumber, (void *) &SwigClassDuplicateFieldNumber);
  rb_define_alloc_func(SwigClassDuplicateFieldNumber.klass, _wrap_DuplicateFieldNumber_allocate);
  rb_define_method(SwigClassDuplicateFieldNumber.klass, "initialize", VALUEFUNC(_wrap_new_DuplicateFieldNumber), -1);
  SwigClassDuplicateFieldNumber.mark = 0;
  SwigClassDuplicateFieldNumber.destroy = (void (*)(void *)) free_FIX_DuplicateFieldNumber;
  SwigClassDuplicateFieldNumber.trackObjects = 0;
  
  SwigClassInvalidMessageType.klass = rb_define_class_under(mQuickfix, "InvalidMessageType", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvalidMessageType, (void *) &SwigClassInvalidMessageType);
  rb_define_alloc_func(SwigClassInvalidMessageType.klass, _wrap_InvalidMessageType_allocate);
  rb_define_method(SwigClassInvalidMessageType.klass, "initialize", VALUEFUNC(_wrap_new_InvalidMessageType), -1);
  SwigClassInvalidMessageType.mark = 0;
  SwigClassInvalidMessageType.destroy = (void (*)(void *)) free_FIX_InvalidMessageType;
  SwigClassInvalidMessageType.trackObjects = 0;
  
  SwigClassUnsupportedMessageType.klass = rb_define_class_under(mQuickfix, "UnsupportedMessageType", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnsupportedMessageType, (void *) &SwigClassUnsupportedMessageType);
  rb_define_alloc_func(SwigClassUnsupportedMessageType.klass, _wrap_UnsupportedMessageType_allocate);
  rb_define_method(SwigClassUnsupportedMessageType.klass, "initialize", VALUEFUNC(_wrap_new_UnsupportedMessageType), -1);
  SwigClassUnsupportedMessageType.mark = 0;
  SwigClassUnsupportedMessageType.destroy = (void (*)(void *)) free_FIX_UnsupportedMessageType;
  SwigClassUnsupportedMessageType.trackObjects = 0;
  
  SwigClassUnsupportedVersion.klass = rb_define_class_under(mQuickfix, "UnsupportedVersion", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnsupportedVersion, (void *) &SwigClassUnsupportedVersion);
  rb_define_alloc_func(SwigClassUnsupportedVersion.klass, _wrap_UnsupportedVersion_allocate);
  rb_define_method(SwigClassUnsupportedVersion.klass, "initialize", VALUEFUNC(_wrap_new_UnsupportedVersion), -1);
  SwigClassUnsupportedVersion.mark = 0;
  SwigClassUnsupportedVersion.destroy = (void (*)(void *)) free_FIX_UnsupportedVersion;
  SwigClassUnsupportedVersion.trackObjects = 0;
  
  SwigClassTagOutOfOrder.klass = rb_define_class_under(mQuickfix, "TagOutOfOrder", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TagOutOfOrder, (void *) &SwigClassTagOutOfOrder);
  rb_define_alloc_func(SwigClassTagOutOfOrder.klass, _wrap_TagOutOfOrder_allocate);
  rb_define_method(SwigClassTagOutOfOrder.klass, "initialize", VALUEFUNC(_wrap_new_TagOutOfOrder), -1);
  rb_define_method(SwigClassTagOutOfOrder.klass, "field=", VALUEFUNC(_wrap_TagOutOfOrder_field_set), -1);
  rb_define_method(SwigClassTagOutOfOrder.klass, "field", VALUEFUNC(_wrap_TagOutOfOrder_field_get), -1);
  SwigClassTagOutOfOrder.mark = 0;
  SwigClassTagOutOfOrder.destroy = (void (*)(void *)) free_FIX_TagOutOfOrder;
  SwigClassTagOutOfOrder.trackObjects = 0;
  
  SwigClassRepeatedTag.klass = rb_define_class_under(mQuickfix, "RepeatedTag", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepeatedTag, (void *) &SwigClassRepeatedTag);
  rb_define_alloc_func(SwigClassRepeatedTag.klass, _wrap_RepeatedTag_allocate);
  rb_define_method(SwigClassRepeatedTag.klass, "initialize", VALUEFUNC(_wrap_new_RepeatedTag), -1);
  rb_define_method(SwigClassRepeatedTag.klass, "field=", VALUEFUNC(_wrap_RepeatedTag_field_set), -1);
  rb_define_method(SwigClassRepeatedTag.klass, "field", VALUEFUNC(_wrap_RepeatedTag_field_get), -1);
  SwigClassRepeatedTag.mark = 0;
  SwigClassRepeatedTag.destroy = (void (*)(void *)) free_FIX_RepeatedTag;
  SwigClassRepeatedTag.trackObjects = 0;
  
  SwigClassRepeatingGroupCountMismatch.klass = rb_define_class_under(mQuickfix, "RepeatingGroupCountMismatch", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, (void *) &SwigClassRepeatingGroupCountMismatch);
  rb_define_alloc_func(SwigClassRepeatingGroupCountMismatch.klass, _wrap_RepeatingGroupCountMismatch_allocate);
  rb_define_method(SwigClassRepeatingGroupCountMismatch.klass, "initialize", VALUEFUNC(_wrap_new_RepeatingGroupCountMismatch), -1);
  rb_define_method(SwigClassRepeatingGroupCountMismatch.klass, "field=", VALUEFUNC(_wrap_RepeatingGroupCountMismatch_field_set), -1);
  rb_define_method(SwigClassRepeatingGroupCountMismatch.klass, "field", VALUEFUNC(_wrap_RepeatingGroupCountMismatch_field_get), -1);
  SwigClassRepeatingGroupCountMismatch.mark = 0;
  SwigClassRepeatingGroupCountMismatch.destroy = (void (*)(void *)) free_FIX_RepeatingGroupCountMismatch;
  SwigClassRepeatingGroupCountMismatch.trackObjects = 0;
  
  SwigClassDoNotSend.klass = rb_define_class_under(mQuickfix, "DoNotSend", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DoNotSend, (void *) &SwigClassDoNotSend);
  rb_define_alloc_func(SwigClassDoNotSend.klass, _wrap_DoNotSend_allocate);
  rb_define_method(SwigClassDoNotSend.klass, "initialize", VALUEFUNC(_wrap_new_DoNotSend), -1);
  SwigClassDoNotSend.mark = 0;
  SwigClassDoNotSend.destroy = (void (*)(void *)) free_FIX_DoNotSend;
  SwigClassDoNotSend.trackObjects = 0;
  
  SwigClassRejectLogon.klass = rb_define_class_under(mQuickfix, "RejectLogon", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RejectLogon, (void *) &SwigClassRejectLogon);
  rb_define_alloc_func(SwigClassRejectLogon.klass, _wrap_RejectLogon_allocate);
  rb_define_method(SwigClassRejectLogon.klass, "initialize", VALUEFUNC(_wrap_new_RejectLogon), -1);
  SwigClassRejectLogon.mark = 0;
  SwigClassRejectLogon.destroy = (void (*)(void *)) free_FIX_RejectLogon;
  SwigClassRejectLogon.trackObjects = 0;
  
  SwigClassSessionNotFound.klass = rb_define_class_under(mQuickfix, "SessionNotFound", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionNotFound, (void *) &SwigClassSessionNotFound);
  rb_define_alloc_func(SwigClassSessionNotFound.klass, _wrap_SessionNotFound_allocate);
  rb_define_method(SwigClassSessionNotFound.klass, "initialize", VALUEFUNC(_wrap_new_SessionNotFound), -1);
  SwigClassSessionNotFound.mark = 0;
  SwigClassSessionNotFound.destroy = (void (*)(void *)) free_FIX_SessionNotFound;
  SwigClassSessionNotFound.trackObjects = 0;
  
  SwigClassIOException.klass = rb_define_class_under(mQuickfix, "IOException", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOException, (void *) &SwigClassIOException);
  rb_define_alloc_func(SwigClassIOException.klass, _wrap_IOException_allocate);
  rb_define_method(SwigClassIOException.klass, "initialize", VALUEFUNC(_wrap_new_IOException), -1);
  SwigClassIOException.mark = 0;
  SwigClassIOException.destroy = (void (*)(void *)) free_FIX_IOException;
  SwigClassIOException.trackObjects = 0;
  
  SwigClassSocketException.klass = rb_define_class_under(mQuickfix, "SocketException", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketException, (void *) &SwigClassSocketException);
  rb_define_alloc_func(SwigClassSocketException.klass, _wrap_SocketException_allocate);
  rb_define_method(SwigClassSocketException.klass, "initialize", VALUEFUNC(_wrap_new_SocketException), -1);
  rb_define_method(SwigClassSocketException.klass, "errorToWhat", VALUEFUNC(_wrap_SocketException_errorToWhat), -1);
  rb_define_method(SwigClassSocketException.klass, "error=", VALUEFUNC(_wrap_SocketException_error_set), -1);
  rb_define_method(SwigClassSocketException.klass, "error", VALUEFUNC(_wrap_SocketException_error_get), -1);
  SwigClassSocketException.mark = 0;
  SwigClassSocketException.destroy = (void (*)(void *)) free_FIX_SocketException;
  SwigClassSocketException.trackObjects = 0;
  
  SwigClassSocketSendFailed.klass = rb_define_class_under(mQuickfix, "SocketSendFailed", ((swig_class *) SWIGTYPE_p_FIX__SocketException->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketSendFailed, (void *) &SwigClassSocketSendFailed);
  rb_define_alloc_func(SwigClassSocketSendFailed.klass, _wrap_SocketSendFailed_allocate);
  rb_define_method(SwigClassSocketSendFailed.klass, "initialize", VALUEFUNC(_wrap_new_SocketSendFailed), -1);
  SwigClassSocketSendFailed.mark = 0;
  SwigClassSocketSendFailed.destroy = (void (*)(void *)) free_FIX_SocketSendFailed;
  SwigClassSocketSendFailed.trackObjects = 0;
  
  SwigClassSocketRecvFailed.klass = rb_define_class_under(mQuickfix, "SocketRecvFailed", ((swig_class *) SWIGTYPE_p_FIX__SocketException->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketRecvFailed, (void *) &SwigClassSocketRecvFailed);
  rb_define_alloc_func(SwigClassSocketRecvFailed.klass, _wrap_SocketRecvFailed_allocate);
  rb_define_method(SwigClassSocketRecvFailed.klass, "initialize", VALUEFUNC(_wrap_new_SocketRecvFailed), -1);
  SwigClassSocketRecvFailed.mark = 0;
  SwigClassSocketRecvFailed.destroy = (void (*)(void *)) free_FIX_SocketRecvFailed;
  SwigClassSocketRecvFailed.trackObjects = 0;
  
  SwigClassSocketCloseFailed.klass = rb_define_class_under(mQuickfix, "SocketCloseFailed", ((swig_class *) SWIGTYPE_p_FIX__SocketException->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketCloseFailed, (void *) &SwigClassSocketCloseFailed);
  rb_define_alloc_func(SwigClassSocketCloseFailed.klass, _wrap_SocketCloseFailed_allocate);
  rb_define_method(SwigClassSocketCloseFailed.klass, "initialize", VALUEFUNC(_wrap_new_SocketCloseFailed), -1);
  SwigClassSocketCloseFailed.mark = 0;
  SwigClassSocketCloseFailed.destroy = (void (*)(void *)) free_FIX_SocketCloseFailed;
  SwigClassSocketCloseFailed.trackObjects = 0;
  
  SwigClassFieldBase.klass = rb_define_class_under(mQuickfix, "FieldBase", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldBase, (void *) &SwigClassFieldBase);
  rb_define_alloc_func(SwigClassFieldBase.klass, _wrap_FieldBase_allocate);
  rb_define_method(SwigClassFieldBase.klass, "initialize", VALUEFUNC(_wrap_new_FieldBase), -1);
  rb_define_method(SwigClassFieldBase.klass, "setField", VALUEFUNC(_wrap_FieldBase_setField), -1);
  rb_define_method(SwigClassFieldBase.klass, "setString", VALUEFUNC(_wrap_FieldBase_setString), -1);
  rb_define_method(SwigClassFieldBase.klass, "getField", VALUEFUNC(_wrap_FieldBase_getField), -1);
  rb_define_method(SwigClassFieldBase.klass, "getString", VALUEFUNC(_wrap_FieldBase_getString), -1);
  rb_define_method(SwigClassFieldBase.klass, "getFixString", VALUEFUNC(_wrap_FieldBase_getFixString), -1);
  rb_define_method(SwigClassFieldBase.klass, "getLength", VALUEFUNC(_wrap_FieldBase_getLength), -1);
  rb_define_method(SwigClassFieldBase.klass, "getTotal", VALUEFUNC(_wrap_FieldBase_getTotal), -1);
  rb_define_method(SwigClassFieldBase.klass, "<", VALUEFUNC(_wrap_FieldBase___lt__), -1);
  rb_define_method(SwigClassFieldBase.klass, "to_s", VALUEFUNC(_wrap_FieldBase___str__), -1);
  SwigClassFieldBase.mark = 0;
  SwigClassFieldBase.destroy = (void (*)(void *)) free_FIX_FieldBase;
  SwigClassFieldBase.trackObjects = 0;
  
  SwigClassStringField.klass = rb_define_class_under(mQuickfix, "StringField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StringField, (void *) &SwigClassStringField);
  rb_define_alloc_func(SwigClassStringField.klass, _wrap_StringField_allocate);
  rb_define_method(SwigClassStringField.klass, "initialize", VALUEFUNC(_wrap_new_StringField), -1);
  rb_define_method(SwigClassStringField.klass, "setValue", VALUEFUNC(_wrap_StringField_setValue), -1);
  rb_define_method(SwigClassStringField.klass, "getValue", VALUEFUNC(_wrap_StringField_getValue), -1);
  rb_define_method(SwigClassStringField.klass, "<", VALUEFUNC(_wrap_StringField___lt__), -1);
  rb_define_method(SwigClassStringField.klass, ">", VALUEFUNC(_wrap_StringField___gt__), -1);
  rb_define_method(SwigClassStringField.klass, "==", VALUEFUNC(_wrap_StringField___eq__), -1);
  rb_define_method(SwigClassStringField.klass, "<=", VALUEFUNC(_wrap_StringField___le__), -1);
  rb_define_method(SwigClassStringField.klass, ">=", VALUEFUNC(_wrap_StringField___ge__), -1);
  SwigClassStringField.mark = 0;
  SwigClassStringField.destroy = (void (*)(void *)) free_FIX_StringField;
  SwigClassStringField.trackObjects = 0;
  rb_define_module_function(mQuickfix, ">", VALUEFUNC(_wrap___gt__), -1);
  rb_define_module_function(mQuickfix, "<=", VALUEFUNC(_wrap___le__), -1);
  rb_define_module_function(mQuickfix, ">=", VALUEFUNC(_wrap___ge__), -1);
  
  SwigClassCharField.klass = rb_define_class_under(mQuickfix, "CharField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CharField, (void *) &SwigClassCharField);
  rb_define_alloc_func(SwigClassCharField.klass, _wrap_CharField_allocate);
  rb_define_method(SwigClassCharField.klass, "initialize", VALUEFUNC(_wrap_new_CharField), -1);
  rb_define_method(SwigClassCharField.klass, "setValue", VALUEFUNC(_wrap_CharField_setValue), -1);
  rb_define_method(SwigClassCharField.klass, "getValue", VALUEFUNC(_wrap_CharField_getValue), -1);
  SwigClassCharField.mark = 0;
  SwigClassCharField.destroy = (void (*)(void *)) free_FIX_CharField;
  SwigClassCharField.trackObjects = 0;
  
  SwigClassDoubleField.klass = rb_define_class_under(mQuickfix, "DoubleField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DoubleField, (void *) &SwigClassDoubleField);
  rb_define_alloc_func(SwigClassDoubleField.klass, _wrap_DoubleField_allocate);
  rb_define_method(SwigClassDoubleField.klass, "initialize", VALUEFUNC(_wrap_new_DoubleField), -1);
  rb_define_method(SwigClassDoubleField.klass, "setValue", VALUEFUNC(_wrap_DoubleField_setValue), -1);
  rb_define_method(SwigClassDoubleField.klass, "getValue", VALUEFUNC(_wrap_DoubleField_getValue), -1);
  SwigClassDoubleField.mark = 0;
  SwigClassDoubleField.destroy = (void (*)(void *)) free_FIX_DoubleField;
  SwigClassDoubleField.trackObjects = 0;
  
  SwigClassIntField.klass = rb_define_class_under(mQuickfix, "IntField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IntField, (void *) &SwigClassIntField);
  rb_define_alloc_func(SwigClassIntField.klass, _wrap_IntField_allocate);
  rb_define_method(SwigClassIntField.klass, "initialize", VALUEFUNC(_wrap_new_IntField), -1);
  rb_define_method(SwigClassIntField.klass, "setValue", VALUEFUNC(_wrap_IntField_setValue), -1);
  rb_define_method(SwigClassIntField.klass, "getValue", VALUEFUNC(_wrap_IntField_getValue), -1);
  SwigClassIntField.mark = 0;
  SwigClassIntField.destroy = (void (*)(void *)) free_FIX_IntField;
  SwigClassIntField.trackObjects = 0;
  
  SwigClassBoolField.klass = rb_define_class_under(mQuickfix, "BoolField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BoolField, (void *) &SwigClassBoolField);
  rb_define_alloc_func(SwigClassBoolField.klass, _wrap_BoolField_allocate);
  rb_define_method(SwigClassBoolField.klass, "initialize", VALUEFUNC(_wrap_new_BoolField), -1);
  rb_define_method(SwigClassBoolField.klass, "setValue", VALUEFUNC(_wrap_BoolField_setValue), -1);
  rb_define_method(SwigClassBoolField.klass, "getValue", VALUEFUNC(_wrap_BoolField_getValue), -1);
  SwigClassBoolField.mark = 0;
  SwigClassBoolField.destroy = (void (*)(void *)) free_FIX_BoolField;
  SwigClassBoolField.trackObjects = 0;
  
  SwigClassUtcTimeStampField.klass = rb_define_class_under(mQuickfix, "UtcTimeStampField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UtcTimeStampField, (void *) &SwigClassUtcTimeStampField);
  rb_define_alloc_func(SwigClassUtcTimeStampField.klass, _wrap_UtcTimeStampField_allocate);
  rb_define_method(SwigClassUtcTimeStampField.klass, "initialize", VALUEFUNC(_wrap_new_UtcTimeStampField), -1);
  rb_define_method(SwigClassUtcTimeStampField.klass, "setValue", VALUEFUNC(_wrap_UtcTimeStampField_setValue), -1);
  rb_define_method(SwigClassUtcTimeStampField.klass, "getValue", VALUEFUNC(_wrap_UtcTimeStampField_getValue), -1);
  rb_define_method(SwigClassUtcTimeStampField.klass, "<", VALUEFUNC(_wrap_UtcTimeStampField___lt__), -1);
  rb_define_method(SwigClassUtcTimeStampField.klass, "==", VALUEFUNC(_wrap_UtcTimeStampField___eq__), -1);
  SwigClassUtcTimeStampField.mark = 0;
  SwigClassUtcTimeStampField.destroy = (void (*)(void *)) free_FIX_UtcTimeStampField;
  SwigClassUtcTimeStampField.trackObjects = 0;
  
  SwigClassUtcDateField.klass = rb_define_class_under(mQuickfix, "UtcDateField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UtcDateField, (void *) &SwigClassUtcDateField);
  rb_define_alloc_func(SwigClassUtcDateField.klass, _wrap_UtcDateField_allocate);
  rb_define_method(SwigClassUtcDateField.klass, "initialize", VALUEFUNC(_wrap_new_UtcDateField), -1);
  rb_define_method(SwigClassUtcDateField.klass, "setValue", VALUEFUNC(_wrap_UtcDateField_setValue), -1);
  rb_define_method(SwigClassUtcDateField.klass, "getValue", VALUEFUNC(_wrap_UtcDateField_getValue), -1);
  rb_define_method(SwigClassUtcDateField.klass, "<", VALUEFUNC(_wrap_UtcDateField___lt__), -1);
  rb_define_method(SwigClassUtcDateField.klass, "==", VALUEFUNC(_wrap_UtcDateField___eq__), -1);
  SwigClassUtcDateField.mark = 0;
  SwigClassUtcDateField.destroy = (void (*)(void *)) free_FIX_UtcDateField;
  SwigClassUtcDateField.trackObjects = 0;
  
  SwigClassUtcTimeOnlyField.klass = rb_define_class_under(mQuickfix, "UtcTimeOnlyField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UtcTimeOnlyField, (void *) &SwigClassUtcTimeOnlyField);
  rb_define_alloc_func(SwigClassUtcTimeOnlyField.klass, _wrap_UtcTimeOnlyField_allocate);
  rb_define_method(SwigClassUtcTimeOnlyField.klass, "initialize", VALUEFUNC(_wrap_new_UtcTimeOnlyField), -1);
  rb_define_method(SwigClassUtcTimeOnlyField.klass, "setValue", VALUEFUNC(_wrap_UtcTimeOnlyField_setValue), -1);
  rb_define_method(SwigClassUtcTimeOnlyField.klass, "getValue", VALUEFUNC(_wrap_UtcTimeOnlyField_getValue), -1);
  rb_define_method(SwigClassUtcTimeOnlyField.klass, "<", VALUEFUNC(_wrap_UtcTimeOnlyField___lt__), -1);
  rb_define_method(SwigClassUtcTimeOnlyField.klass, "==", VALUEFUNC(_wrap_UtcTimeOnlyField___eq__), -1);
  SwigClassUtcTimeOnlyField.mark = 0;
  SwigClassUtcTimeOnlyField.destroy = (void (*)(void *)) free_FIX_UtcTimeOnlyField;
  SwigClassUtcTimeOnlyField.trackObjects = 0;
  
  SwigClassCheckSumField.klass = rb_define_class_under(mQuickfix, "CheckSumField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CheckSumField, (void *) &SwigClassCheckSumField);
  rb_define_alloc_func(SwigClassCheckSumField.klass, _wrap_CheckSumField_allocate);
  rb_define_method(SwigClassCheckSumField.klass, "initialize", VALUEFUNC(_wrap_new_CheckSumField), -1);
  rb_define_method(SwigClassCheckSumField.klass, "setValue", VALUEFUNC(_wrap_CheckSumField_setValue), -1);
  rb_define_method(SwigClassCheckSumField.klass, "getValue", VALUEFUNC(_wrap_CheckSumField_getValue), -1);
  SwigClassCheckSumField.mark = 0;
  SwigClassCheckSumField.destroy = (void (*)(void *)) free_FIX_CheckSumField;
  SwigClassCheckSumField.trackObjects = 0;
  
  SwigClassFieldMap.klass = rb_define_class_under(mQuickfix, "FieldMap", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldMap, (void *) &SwigClassFieldMap);
  rb_define_alloc_func(SwigClassFieldMap.klass, _wrap_FieldMap_allocate);
  rb_define_method(SwigClassFieldMap.klass, "initialize", VALUEFUNC(_wrap_new_FieldMap), -1);
  rb_define_method(SwigClassFieldMap.klass, "setField", VALUEFUNC(_wrap_FieldMap_setField), -1);
  rb_define_method(SwigClassFieldMap.klass, "getField", VALUEFUNC(_wrap_FieldMap_getField), -1);
  rb_define_method(SwigClassFieldMap.klass, "getFieldRef", VALUEFUNC(_wrap_FieldMap_getFieldRef), -1);
  rb_define_method(SwigClassFieldMap.klass, "getFieldPtr", VALUEFUNC(_wrap_FieldMap_getFieldPtr), -1);
  rb_define_method(SwigClassFieldMap.klass, "isSetField", VALUEFUNC(_wrap_FieldMap_isSetField), -1);
  rb_define_method(SwigClassFieldMap.klass, "removeField", VALUEFUNC(_wrap_FieldMap_removeField), -1);
  rb_define_method(SwigClassFieldMap.klass, "addGroup", VALUEFUNC(_wrap_FieldMap_addGroup), -1);
  rb_define_method(SwigClassFieldMap.klass, "replaceGroup", VALUEFUNC(_wrap_FieldMap_replaceGroup), -1);
  rb_define_method(SwigClassFieldMap.klass, "getGroup", VALUEFUNC(_wrap_FieldMap_getGroup), -1);
  rb_define_method(SwigClassFieldMap.klass, "getGroupRef", VALUEFUNC(_wrap_FieldMap_getGroupRef), -1);
  rb_define_method(SwigClassFieldMap.klass, "getGroupPtr", VALUEFUNC(_wrap_FieldMap_getGroupPtr), -1);
  rb_define_method(SwigClassFieldMap.klass, "removeGroup", VALUEFUNC(_wrap_FieldMap_removeGroup), -1);
  rb_define_method(SwigClassFieldMap.klass, "hasGroup", VALUEFUNC(_wrap_FieldMap_hasGroup), -1);
  rb_define_method(SwigClassFieldMap.klass, "groupCount", VALUEFUNC(_wrap_FieldMap_groupCount), -1);
  rb_define_method(SwigClassFieldMap.klass, "clear", VALUEFUNC(_wrap_FieldMap_clear), -1);
  rb_define_method(SwigClassFieldMap.klass, "isEmpty", VALUEFUNC(_wrap_FieldMap_isEmpty), -1);
  rb_define_method(SwigClassFieldMap.klass, "totalFields", VALUEFUNC(_wrap_FieldMap_totalFields), -1);
  rb_define_method(SwigClassFieldMap.klass, "calculateString", VALUEFUNC(_wrap_FieldMap_calculateString), -1);
  rb_define_method(SwigClassFieldMap.klass, "calculateLength", VALUEFUNC(_wrap_FieldMap_calculateLength), -1);
  rb_define_method(SwigClassFieldMap.klass, "calculateTotal", VALUEFUNC(_wrap_FieldMap_calculateTotal), -1);
  rb_define_method(SwigClassFieldMap.klass, "begin", VALUEFUNC(_wrap_FieldMap_begin), -1);
  rb_define_method(SwigClassFieldMap.klass, "end", VALUEFUNC(_wrap_FieldMap_end), -1);
  rb_define_method(SwigClassFieldMap.klass, "g_begin", VALUEFUNC(_wrap_FieldMap_g_begin), -1);
  rb_define_method(SwigClassFieldMap.klass, "g_end", VALUEFUNC(_wrap_FieldMap_g_end), -1);
  SwigClassFieldMap.mark = 0;
  SwigClassFieldMap.destroy = (void (*)(void *)) free_FIX_FieldMap;
  SwigClassFieldMap.trackObjects = 0;
  rb_define_singleton_method(mQuickfix, "headerOrder", VALUEFUNC(_wrap_headerOrder_get), 0);
  
  SwigClassHeader.klass = rb_define_class_under(mQuickfix, "Header", ((swig_class *) SWIGTYPE_p_FIX__FieldMap->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Header, (void *) &SwigClassHeader);
  rb_define_alloc_func(SwigClassHeader.klass, _wrap_Header_allocate);
  rb_define_method(SwigClassHeader.klass, "initialize", VALUEFUNC(_wrap_new_Header), -1);
  SwigClassHeader.mark = 0;
  SwigClassHeader.destroy = (void (*)(void *)) free_FIX_Header;
  SwigClassHeader.trackObjects = 0;
  
  SwigClassTrailer.klass = rb_define_class_under(mQuickfix, "Trailer", ((swig_class *) SWIGTYPE_p_FIX__FieldMap->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Trailer, (void *) &SwigClassTrailer);
  rb_define_alloc_func(SwigClassTrailer.klass, _wrap_Trailer_allocate);
  rb_define_method(SwigClassTrailer.klass, "initialize", VALUEFUNC(_wrap_new_Trailer), -1);
  SwigClassTrailer.mark = 0;
  SwigClassTrailer.destroy = (void (*)(void *)) free_FIX_Trailer;
  SwigClassTrailer.trackObjects = 0;
  
  SwigClassMessage.klass = rb_define_class_under(mQuickfix, "Message", ((swig_class *) SWIGTYPE_p_FIX__FieldMap->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Message, (void *) &SwigClassMessage);
  rb_define_alloc_func(SwigClassMessage.klass, _wrap_Message_allocate);
  rb_define_method(SwigClassMessage.klass, "initialize", VALUEFUNC(_wrap_new_Message), -1);
  rb_define_singleton_method(SwigClassMessage.klass, "InitializeXML", VALUEFUNC(_wrap_Message_InitializeXML), -1);
  rb_define_method(SwigClassMessage.klass, "addGroup", VALUEFUNC(_wrap_Message_addGroup), -1);
  rb_define_method(SwigClassMessage.klass, "replaceGroup", VALUEFUNC(_wrap_Message_replaceGroup), -1);
  rb_define_method(SwigClassMessage.klass, "getGroup", VALUEFUNC(_wrap_Message_getGroup), -1);
  rb_define_method(SwigClassMessage.klass, "removeGroup", VALUEFUNC(_wrap_Message_removeGroup), -1);
  rb_define_method(SwigClassMessage.klass, "hasGroup", VALUEFUNC(_wrap_Message_hasGroup), -1);
  rb_define_method(SwigClassMessage.klass, "toString", VALUEFUNC(_wrap_Message_toString), -1);
  rb_define_method(SwigClassMessage.klass, "toXML", VALUEFUNC(_wrap_Message_toXML), -1);
  rb_define_method(SwigClassMessage.klass, "reverseRoute", VALUEFUNC(_wrap_Message_reverseRoute), -1);
  rb_define_method(SwigClassMessage.klass, "setString", VALUEFUNC(_wrap_Message_setString), -1);
  rb_define_method(SwigClassMessage.klass, "setGroup", VALUEFUNC(_wrap_Message_setGroup), -1);
  rb_define_method(SwigClassMessage.klass, "setStringHeader", VALUEFUNC(_wrap_Message_setStringHeader), -1);
  rb_define_method(SwigClassMessage.klass, "getHeader", VALUEFUNC(_wrap_Message_getHeader), -1);
  rb_define_method(SwigClassMessage.klass, "getTrailer", VALUEFUNC(_wrap_Message_getTrailer), -1);
  rb_define_method(SwigClassMessage.klass, "hasValidStructure", VALUEFUNC(_wrap_Message_hasValidStructure), -1);
  rb_define_method(SwigClassMessage.klass, "bodyLength", VALUEFUNC(_wrap_Message_bodyLength), -1);
  rb_define_method(SwigClassMessage.klass, "checkSum", VALUEFUNC(_wrap_Message_checkSum), -1);
  rb_define_method(SwigClassMessage.klass, "isAdmin", VALUEFUNC(_wrap_Message_isAdmin), -1);
  rb_define_method(SwigClassMessage.klass, "isApp", VALUEFUNC(_wrap_Message_isApp), -1);
  rb_define_method(SwigClassMessage.klass, "isEmpty", VALUEFUNC(_wrap_Message_isEmpty), -1);
  rb_define_method(SwigClassMessage.klass, "clear", VALUEFUNC(_wrap_Message_clear), -1);
  rb_define_singleton_method(SwigClassMessage.klass, "isAdminMsgType", VALUEFUNC(_wrap_Message_isAdminMsgType), -1);
  rb_define_singleton_method(SwigClassMessage.klass, "toApplVerID", VALUEFUNC(_wrap_Message_toApplVerID), -1);
  rb_define_singleton_method(SwigClassMessage.klass, "toBeginString", VALUEFUNC(_wrap_Message_toBeginString), -1);
  rb_define_singleton_method(SwigClassMessage.klass, "isHeaderField", VALUEFUNC(_wrap_Message_isHeaderField), -1);
  rb_define_singleton_method(SwigClassMessage.klass, "isTrailerField", VALUEFUNC(_wrap_Message_isTrailerField), -1);
  rb_define_method(SwigClassMessage.klass, "getSessionID", VALUEFUNC(_wrap_Message_getSessionID), -1);
  rb_define_method(SwigClassMessage.klass, "setSessionID", VALUEFUNC(_wrap_Message_setSessionID), -1);
  rb_define_method(SwigClassMessage.klass, "to_s", VALUEFUNC(_wrap_Message___str__), -1);
  SwigClassMessage.mark = 0;
  SwigClassMessage.destroy = (void (*)(void *)) free_FIX_Message;
  SwigClassMessage.trackObjects = 0;
  rb_define_module_function(mQuickfix, "identifyType", VALUEFUNC(_wrap_identifyType), -1);
  
  SwigClassGroup.klass = rb_define_class_under(mQuickfix, "Group", ((swig_class *) SWIGTYPE_p_FIX__FieldMap->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Group, (void *) &SwigClassGroup);
  rb_define_alloc_func(SwigClassGroup.klass, _wrap_Group_allocate);
  rb_define_method(SwigClassGroup.klass, "initialize", VALUEFUNC(_wrap_new_Group), -1);
  rb_define_method(SwigClassGroup.klass, "field", VALUEFUNC(_wrap_Group_field), -1);
  rb_define_method(SwigClassGroup.klass, "delim", VALUEFUNC(_wrap_Group_delim), -1);
  rb_define_method(SwigClassGroup.klass, "addGroup", VALUEFUNC(_wrap_Group_addGroup), -1);
  rb_define_method(SwigClassGroup.klass, "replaceGroup", VALUEFUNC(_wrap_Group_replaceGroup), -1);
  rb_define_method(SwigClassGroup.klass, "getGroup", VALUEFUNC(_wrap_Group_getGroup), -1);
  rb_define_method(SwigClassGroup.klass, "removeGroup", VALUEFUNC(_wrap_Group_removeGroup), -1);
  rb_define_method(SwigClassGroup.klass, "hasGroup", VALUEFUNC(_wrap_Group_hasGroup), -1);
  SwigClassGroup.mark = 0;
  SwigClassGroup.destroy = (void (*)(void *)) free_FIX_Group;
  SwigClassGroup.trackObjects = 0;
  
  SwigClassMaxPriceLevels.klass = rb_define_class_under(mQuickfix, "MaxPriceLevels", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxPriceLevels, (void *) &SwigClassMaxPriceLevels);
  rb_define_alloc_func(SwigClassMaxPriceLevels.klass, _wrap_MaxPriceLevels_allocate);
  rb_define_method(SwigClassMaxPriceLevels.klass, "initialize", VALUEFUNC(_wrap_new_MaxPriceLevels), -1);
  SwigClassMaxPriceLevels.mark = 0;
  SwigClassMaxPriceLevels.destroy = (void (*)(void *)) free_FIX_MaxPriceLevels;
  SwigClassMaxPriceLevels.trackObjects = 0;
  
  SwigClassDerivativeEncodedIssuer.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedIssuer, (void *) &SwigClassDerivativeEncodedIssuer);
  rb_define_alloc_func(SwigClassDerivativeEncodedIssuer.klass, _wrap_DerivativeEncodedIssuer_allocate);
  rb_define_method(SwigClassDerivativeEncodedIssuer.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedIssuer), -1);
  SwigClassDerivativeEncodedIssuer.mark = 0;
  SwigClassDerivativeEncodedIssuer.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedIssuer;
  SwigClassDerivativeEncodedIssuer.trackObjects = 0;
  
  SwigClassNoCompIDs.klass = rb_define_class_under(mQuickfix, "NoCompIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoCompIDs, (void *) &SwigClassNoCompIDs);
  rb_define_alloc_func(SwigClassNoCompIDs.klass, _wrap_NoCompIDs_allocate);
  rb_define_method(SwigClassNoCompIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoCompIDs), -1);
  SwigClassNoCompIDs.mark = 0;
  SwigClassNoCompIDs.destroy = (void (*)(void *)) free_FIX_NoCompIDs;
  SwigClassNoCompIDs.trackObjects = 0;
  
  SwigClassSettlInstRefID.klass = rb_define_class_under(mQuickfix, "SettlInstRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstRefID, (void *) &SwigClassSettlInstRefID);
  rb_define_alloc_func(SwigClassSettlInstRefID.klass, _wrap_SettlInstRefID_allocate);
  rb_define_method(SwigClassSettlInstRefID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstRefID), -1);
  SwigClassSettlInstRefID.mark = 0;
  SwigClassSettlInstRefID.destroy = (void (*)(void *)) free_FIX_SettlInstRefID;
  SwigClassSettlInstRefID.trackObjects = 0;
  
  SwigClassNestedPartyID.klass = rb_define_class_under(mQuickfix, "NestedPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartyID, (void *) &SwigClassNestedPartyID);
  rb_define_alloc_func(SwigClassNestedPartyID.klass, _wrap_NestedPartyID_allocate);
  rb_define_method(SwigClassNestedPartyID.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartyID), -1);
  SwigClassNestedPartyID.mark = 0;
  SwigClassNestedPartyID.destroy = (void (*)(void *)) free_FIX_NestedPartyID;
  SwigClassNestedPartyID.trackObjects = 0;
  
  SwigClassDetachmentPoint.klass = rb_define_class_under(mQuickfix, "DetachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DetachmentPoint, (void *) &SwigClassDetachmentPoint);
  rb_define_alloc_func(SwigClassDetachmentPoint.klass, _wrap_DetachmentPoint_allocate);
  rb_define_method(SwigClassDetachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_DetachmentPoint), -1);
  SwigClassDetachmentPoint.mark = 0;
  SwigClassDetachmentPoint.destroy = (void (*)(void *)) free_FIX_DetachmentPoint;
  SwigClassDetachmentPoint.trackObjects = 0;
  
  SwigClassLateIndicator.klass = rb_define_class_under(mQuickfix, "LateIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LateIndicator, (void *) &SwigClassLateIndicator);
  rb_define_alloc_func(SwigClassLateIndicator.klass, _wrap_LateIndicator_allocate);
  rb_define_method(SwigClassLateIndicator.klass, "initialize", VALUEFUNC(_wrap_new_LateIndicator), -1);
  SwigClassLateIndicator.mark = 0;
  SwigClassLateIndicator.destroy = (void (*)(void *)) free_FIX_LateIndicator;
  SwigClassLateIndicator.trackObjects = 0;
  
  SwigClassSecurityListID.klass = rb_define_class_under(mQuickfix, "SecurityListID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListID, (void *) &SwigClassSecurityListID);
  rb_define_alloc_func(SwigClassSecurityListID.klass, _wrap_SecurityListID_allocate);
  rb_define_method(SwigClassSecurityListID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListID), -1);
  SwigClassSecurityListID.mark = 0;
  SwigClassSecurityListID.destroy = (void (*)(void *)) free_FIX_SecurityListID;
  SwigClassSecurityListID.trackObjects = 0;
  
  SwigClassDerivativeFlowScheduleType.klass = rb_define_class_under(mQuickfix, "DerivativeFlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeFlowScheduleType, (void *) &SwigClassDerivativeFlowScheduleType);
  rb_define_alloc_func(SwigClassDerivativeFlowScheduleType.klass, _wrap_DerivativeFlowScheduleType_allocate);
  rb_define_method(SwigClassDerivativeFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeFlowScheduleType), -1);
  SwigClassDerivativeFlowScheduleType.mark = 0;
  SwigClassDerivativeFlowScheduleType.destroy = (void (*)(void *)) free_FIX_DerivativeFlowScheduleType;
  SwigClassDerivativeFlowScheduleType.trackObjects = 0;
  
  SwigClassFlexibleIndicator.klass = rb_define_class_under(mQuickfix, "FlexibleIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FlexibleIndicator, (void *) &SwigClassFlexibleIndicator);
  rb_define_alloc_func(SwigClassFlexibleIndicator.klass, _wrap_FlexibleIndicator_allocate);
  rb_define_method(SwigClassFlexibleIndicator.klass, "initialize", VALUEFUNC(_wrap_new_FlexibleIndicator), -1);
  SwigClassFlexibleIndicator.mark = 0;
  SwigClassFlexibleIndicator.destroy = (void (*)(void *)) free_FIX_FlexibleIndicator;
  SwigClassFlexibleIndicator.trackObjects = 0;
  
  SwigClassNoExecInstRules.klass = rb_define_class_under(mQuickfix, "NoExecInstRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoExecInstRules, (void *) &SwigClassNoExecInstRules);
  rb_define_alloc_func(SwigClassNoExecInstRules.klass, _wrap_NoExecInstRules_allocate);
  rb_define_method(SwigClassNoExecInstRules.klass, "initialize", VALUEFUNC(_wrap_new_NoExecInstRules), -1);
  SwigClassNoExecInstRules.mark = 0;
  SwigClassNoExecInstRules.destroy = (void (*)(void *)) free_FIX_NoExecInstRules;
  SwigClassNoExecInstRules.trackObjects = 0;
  
  SwigClassSideTrdRegTimestamp.klass = rb_define_class_under(mQuickfix, "SideTrdRegTimestamp", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdRegTimestamp, (void *) &SwigClassSideTrdRegTimestamp);
  rb_define_alloc_func(SwigClassSideTrdRegTimestamp.klass, _wrap_SideTrdRegTimestamp_allocate);
  rb_define_method(SwigClassSideTrdRegTimestamp.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdRegTimestamp), -1);
  SwigClassSideTrdRegTimestamp.mark = 0;
  SwigClassSideTrdRegTimestamp.destroy = (void (*)(void *)) free_FIX_SideTrdRegTimestamp;
  SwigClassSideTrdRegTimestamp.trackObjects = 0;
  
  SwigClassDeliveryForm.klass = rb_define_class_under(mQuickfix, "DeliveryForm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliveryForm, (void *) &SwigClassDeliveryForm);
  rb_define_alloc_func(SwigClassDeliveryForm.klass, _wrap_DeliveryForm_allocate);
  rb_define_method(SwigClassDeliveryForm.klass, "initialize", VALUEFUNC(_wrap_new_DeliveryForm), -1);
  SwigClassDeliveryForm.mark = 0;
  SwigClassDeliveryForm.destroy = (void (*)(void *)) free_FIX_DeliveryForm;
  SwigClassDeliveryForm.trackObjects = 0;
  
  SwigClassExecRestatementReason.klass = rb_define_class_under(mQuickfix, "ExecRestatementReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecRestatementReason, (void *) &SwigClassExecRestatementReason);
  rb_define_alloc_func(SwigClassExecRestatementReason.klass, _wrap_ExecRestatementReason_allocate);
  rb_define_method(SwigClassExecRestatementReason.klass, "initialize", VALUEFUNC(_wrap_new_ExecRestatementReason), -1);
  SwigClassExecRestatementReason.mark = 0;
  SwigClassExecRestatementReason.destroy = (void (*)(void *)) free_FIX_ExecRestatementReason;
  SwigClassExecRestatementReason.trackObjects = 0;
  
  SwigClassMidYield.klass = rb_define_class_under(mQuickfix, "MidYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MidYield, (void *) &SwigClassMidYield);
  rb_define_alloc_func(SwigClassMidYield.klass, _wrap_MidYield_allocate);
  rb_define_method(SwigClassMidYield.klass, "initialize", VALUEFUNC(_wrap_new_MidYield), -1);
  SwigClassMidYield.mark = 0;
  SwigClassMidYield.destroy = (void (*)(void *)) free_FIX_MidYield;
  SwigClassMidYield.trackObjects = 0;
  
  SwigClassContractMultiplier.klass = rb_define_class_under(mQuickfix, "ContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContractMultiplier, (void *) &SwigClassContractMultiplier);
  rb_define_alloc_func(SwigClassContractMultiplier.klass, _wrap_ContractMultiplier_allocate);
  rb_define_method(SwigClassContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_ContractMultiplier), -1);
  SwigClassContractMultiplier.mark = 0;
  SwigClassContractMultiplier.destroy = (void (*)(void *)) free_FIX_ContractMultiplier;
  SwigClassContractMultiplier.trackObjects = 0;
  
  SwigClassCcyAmt.klass = rb_define_class_under(mQuickfix, "CcyAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CcyAmt, (void *) &SwigClassCcyAmt);
  rb_define_alloc_func(SwigClassCcyAmt.klass, _wrap_CcyAmt_allocate);
  rb_define_method(SwigClassCcyAmt.klass, "initialize", VALUEFUNC(_wrap_new_CcyAmt), -1);
  SwigClassCcyAmt.mark = 0;
  SwigClassCcyAmt.destroy = (void (*)(void *)) free_FIX_CcyAmt;
  SwigClassCcyAmt.trackObjects = 0;
  
  SwigClassLegOrderQty.klass = rb_define_class_under(mQuickfix, "LegOrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOrderQty, (void *) &SwigClassLegOrderQty);
  rb_define_alloc_func(SwigClassLegOrderQty.klass, _wrap_LegOrderQty_allocate);
  rb_define_method(SwigClassLegOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_LegOrderQty), -1);
  SwigClassLegOrderQty.mark = 0;
  SwigClassLegOrderQty.destroy = (void (*)(void *)) free_FIX_LegOrderQty;
  SwigClassLegOrderQty.trackObjects = 0;
  
  SwigClassAllocIntermedReqType.klass = rb_define_class_under(mQuickfix, "AllocIntermedReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocIntermedReqType, (void *) &SwigClassAllocIntermedReqType);
  rb_define_alloc_func(SwigClassAllocIntermedReqType.klass, _wrap_AllocIntermedReqType_allocate);
  rb_define_method(SwigClassAllocIntermedReqType.klass, "initialize", VALUEFUNC(_wrap_new_AllocIntermedReqType), -1);
  SwigClassAllocIntermedReqType.mark = 0;
  SwigClassAllocIntermedReqType.destroy = (void (*)(void *)) free_FIX_AllocIntermedReqType;
  SwigClassAllocIntermedReqType.trackObjects = 0;
  
  SwigClassUnderlyingIssuer.klass = rb_define_class_under(mQuickfix, "UnderlyingIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingIssuer, (void *) &SwigClassUnderlyingIssuer);
  rb_define_alloc_func(SwigClassUnderlyingIssuer.klass, _wrap_UnderlyingIssuer_allocate);
  rb_define_method(SwigClassUnderlyingIssuer.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingIssuer), -1);
  SwigClassUnderlyingIssuer.mark = 0;
  SwigClassUnderlyingIssuer.destroy = (void (*)(void *)) free_FIX_UnderlyingIssuer;
  SwigClassUnderlyingIssuer.trackObjects = 0;
  
  SwigClassNoNested2PartyIDs.klass = rb_define_class_under(mQuickfix, "NoNested2PartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested2PartyIDs, (void *) &SwigClassNoNested2PartyIDs);
  rb_define_alloc_func(SwigClassNoNested2PartyIDs.klass, _wrap_NoNested2PartyIDs_allocate);
  rb_define_method(SwigClassNoNested2PartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested2PartyIDs), -1);
  SwigClassNoNested2PartyIDs.mark = 0;
  SwigClassNoNested2PartyIDs.destroy = (void (*)(void *)) free_FIX_NoNested2PartyIDs;
  SwigClassNoNested2PartyIDs.trackObjects = 0;
  
  SwigClassMinTradeVol.klass = rb_define_class_under(mQuickfix, "MinTradeVol", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinTradeVol, (void *) &SwigClassMinTradeVol);
  rb_define_alloc_func(SwigClassMinTradeVol.klass, _wrap_MinTradeVol_allocate);
  rb_define_method(SwigClassMinTradeVol.klass, "initialize", VALUEFUNC(_wrap_new_MinTradeVol), -1);
  SwigClassMinTradeVol.mark = 0;
  SwigClassMinTradeVol.destroy = (void (*)(void *)) free_FIX_MinTradeVol;
  SwigClassMinTradeVol.trackObjects = 0;
  
  SwigClassSettlCurrAmt.klass = rb_define_class_under(mQuickfix, "SettlCurrAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrAmt, (void *) &SwigClassSettlCurrAmt);
  rb_define_alloc_func(SwigClassSettlCurrAmt.klass, _wrap_SettlCurrAmt_allocate);
  rb_define_method(SwigClassSettlCurrAmt.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrAmt), -1);
  SwigClassSettlCurrAmt.mark = 0;
  SwigClassSettlCurrAmt.destroy = (void (*)(void *)) free_FIX_SettlCurrAmt;
  SwigClassSettlCurrAmt.trackObjects = 0;
  
  SwigClassDerivativeInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole, (void *) &SwigClassDerivativeInstrumentPartyRole);
  rb_define_alloc_func(SwigClassDerivativeInstrumentPartyRole.klass, _wrap_DerivativeInstrumentPartyRole_allocate);
  rb_define_method(SwigClassDerivativeInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartyRole), -1);
  SwigClassDerivativeInstrumentPartyRole.mark = 0;
  SwigClassDerivativeInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartyRole;
  SwigClassDerivativeInstrumentPartyRole.trackObjects = 0;
  
  SwigClassYieldRedemptionPriceType.klass = rb_define_class_under(mQuickfix, "YieldRedemptionPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldRedemptionPriceType, (void *) &SwigClassYieldRedemptionPriceType);
  rb_define_alloc_func(SwigClassYieldRedemptionPriceType.klass, _wrap_YieldRedemptionPriceType_allocate);
  rb_define_method(SwigClassYieldRedemptionPriceType.klass, "initialize", VALUEFUNC(_wrap_new_YieldRedemptionPriceType), -1);
  SwigClassYieldRedemptionPriceType.mark = 0;
  SwigClassYieldRedemptionPriceType.destroy = (void (*)(void *)) free_FIX_YieldRedemptionPriceType;
  SwigClassYieldRedemptionPriceType.trackObjects = 0;
  
  SwigClassNewsRefID.klass = rb_define_class_under(mQuickfix, "NewsRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsRefID, (void *) &SwigClassNewsRefID);
  rb_define_alloc_func(SwigClassNewsRefID.klass, _wrap_NewsRefID_allocate);
  rb_define_method(SwigClassNewsRefID.klass, "initialize", VALUEFUNC(_wrap_new_NewsRefID), -1);
  SwigClassNewsRefID.mark = 0;
  SwigClassNewsRefID.destroy = (void (*)(void *)) free_FIX_NewsRefID;
  SwigClassNewsRefID.trackObjects = 0;
  
  SwigClassSecurityListTypeSource.klass = rb_define_class_under(mQuickfix, "SecurityListTypeSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListTypeSource, (void *) &SwigClassSecurityListTypeSource);
  rb_define_alloc_func(SwigClassSecurityListTypeSource.klass, _wrap_SecurityListTypeSource_allocate);
  rb_define_method(SwigClassSecurityListTypeSource.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListTypeSource), -1);
  SwigClassSecurityListTypeSource.mark = 0;
  SwigClassSecurityListTypeSource.destroy = (void (*)(void *)) free_FIX_SecurityListTypeSource;
  SwigClassSecurityListTypeSource.trackObjects = 0;
  
  SwigClassApplReqID.klass = rb_define_class_under(mQuickfix, "ApplReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReqID, (void *) &SwigClassApplReqID);
  rb_define_alloc_func(SwigClassApplReqID.klass, _wrap_ApplReqID_allocate);
  rb_define_method(SwigClassApplReqID.klass, "initialize", VALUEFUNC(_wrap_new_ApplReqID), -1);
  SwigClassApplReqID.mark = 0;
  SwigClassApplReqID.destroy = (void (*)(void *)) free_FIX_ApplReqID;
  SwigClassApplReqID.trackObjects = 0;
  
  SwigClassDerivativeFuturesValuationMethod.klass = rb_define_class_under(mQuickfix, "DerivativeFuturesValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod, (void *) &SwigClassDerivativeFuturesValuationMethod);
  rb_define_alloc_func(SwigClassDerivativeFuturesValuationMethod.klass, _wrap_DerivativeFuturesValuationMethod_allocate);
  rb_define_method(SwigClassDerivativeFuturesValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeFuturesValuationMethod), -1);
  SwigClassDerivativeFuturesValuationMethod.mark = 0;
  SwigClassDerivativeFuturesValuationMethod.destroy = (void (*)(void *)) free_FIX_DerivativeFuturesValuationMethod;
  SwigClassDerivativeFuturesValuationMethod.trackObjects = 0;
  
  SwigClassNoLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoLegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegSecurityAltID, (void *) &SwigClassNoLegSecurityAltID);
  rb_define_alloc_func(SwigClassNoLegSecurityAltID.klass, _wrap_NoLegSecurityAltID_allocate);
  rb_define_method(SwigClassNoLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoLegSecurityAltID), -1);
  SwigClassNoLegSecurityAltID.mark = 0;
  SwigClassNoLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoLegSecurityAltID;
  SwigClassNoLegSecurityAltID.trackObjects = 0;
  
  SwigClassDerivativeSecurityType.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityType, (void *) &SwigClassDerivativeSecurityType);
  rb_define_alloc_func(SwigClassDerivativeSecurityType.klass, _wrap_DerivativeSecurityType_allocate);
  rb_define_method(SwigClassDerivativeSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityType), -1);
  SwigClassDerivativeSecurityType.mark = 0;
  SwigClassDerivativeSecurityType.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityType;
  SwigClassDerivativeSecurityType.trackObjects = 0;
  
  SwigClassCollInquiryQualifier.klass = rb_define_class_under(mQuickfix, "CollInquiryQualifier", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryQualifier, (void *) &SwigClassCollInquiryQualifier);
  rb_define_alloc_func(SwigClassCollInquiryQualifier.klass, _wrap_CollInquiryQualifier_allocate);
  rb_define_method(SwigClassCollInquiryQualifier.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryQualifier), -1);
  SwigClassCollInquiryQualifier.mark = 0;
  SwigClassCollInquiryQualifier.destroy = (void (*)(void *)) free_FIX_CollInquiryQualifier;
  SwigClassCollInquiryQualifier.trackObjects = 0;
  
  SwigClassRawData.klass = rb_define_class_under(mQuickfix, "RawData", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RawData, (void *) &SwigClassRawData);
  rb_define_alloc_func(SwigClassRawData.klass, _wrap_RawData_allocate);
  rb_define_method(SwigClassRawData.klass, "initialize", VALUEFUNC(_wrap_new_RawData), -1);
  SwigClassRawData.mark = 0;
  SwigClassRawData.destroy = (void (*)(void *)) free_FIX_RawData;
  SwigClassRawData.trackObjects = 0;
  
  SwigClassCashSettlAgentContactPhone.klass = rb_define_class_under(mQuickfix, "CashSettlAgentContactPhone", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentContactPhone, (void *) &SwigClassCashSettlAgentContactPhone);
  rb_define_alloc_func(SwigClassCashSettlAgentContactPhone.klass, _wrap_CashSettlAgentContactPhone_allocate);
  rb_define_method(SwigClassCashSettlAgentContactPhone.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentContactPhone), -1);
  SwigClassCashSettlAgentContactPhone.mark = 0;
  SwigClassCashSettlAgentContactPhone.destroy = (void (*)(void *)) free_FIX_CashSettlAgentContactPhone;
  SwigClassCashSettlAgentContactPhone.trackObjects = 0;
  
  SwigClassCreditRating.klass = rb_define_class_under(mQuickfix, "CreditRating", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CreditRating, (void *) &SwigClassCreditRating);
  rb_define_alloc_func(SwigClassCreditRating.klass, _wrap_CreditRating_allocate);
  rb_define_method(SwigClassCreditRating.klass, "initialize", VALUEFUNC(_wrap_new_CreditRating), -1);
  SwigClassCreditRating.mark = 0;
  SwigClassCreditRating.destroy = (void (*)(void *)) free_FIX_CreditRating;
  SwigClassCreditRating.trackObjects = 0;
  
  SwigClassContingencyType.klass = rb_define_class_under(mQuickfix, "ContingencyType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContingencyType, (void *) &SwigClassContingencyType);
  rb_define_alloc_func(SwigClassContingencyType.klass, _wrap_ContingencyType_allocate);
  rb_define_method(SwigClassContingencyType.klass, "initialize", VALUEFUNC(_wrap_new_ContingencyType), -1);
  SwigClassContingencyType.mark = 0;
  SwigClassContingencyType.destroy = (void (*)(void *)) free_FIX_ContingencyType;
  SwigClassContingencyType.trackObjects = 0;
  
  SwigClassStrikeCurrency.klass = rb_define_class_under(mQuickfix, "StrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeCurrency, (void *) &SwigClassStrikeCurrency);
  rb_define_alloc_func(SwigClassStrikeCurrency.klass, _wrap_StrikeCurrency_allocate);
  rb_define_method(SwigClassStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_StrikeCurrency), -1);
  SwigClassStrikeCurrency.mark = 0;
  SwigClassStrikeCurrency.destroy = (void (*)(void *)) free_FIX_StrikeCurrency;
  SwigClassStrikeCurrency.trackObjects = 0;
  
  SwigClassTradeVolume.klass = rb_define_class_under(mQuickfix, "TradeVolume", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeVolume, (void *) &SwigClassTradeVolume);
  rb_define_alloc_func(SwigClassTradeVolume.klass, _wrap_TradeVolume_allocate);
  rb_define_method(SwigClassTradeVolume.klass, "initialize", VALUEFUNC(_wrap_new_TradeVolume), -1);
  SwigClassTradeVolume.mark = 0;
  SwigClassTradeVolume.destroy = (void (*)(void *)) free_FIX_TradeVolume;
  SwigClassTradeVolume.trackObjects = 0;
  
  SwigClassSideTrdRegTimestampSrc.klass = rb_define_class_under(mQuickfix, "SideTrdRegTimestampSrc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdRegTimestampSrc, (void *) &SwigClassSideTrdRegTimestampSrc);
  rb_define_alloc_func(SwigClassSideTrdRegTimestampSrc.klass, _wrap_SideTrdRegTimestampSrc_allocate);
  rb_define_method(SwigClassSideTrdRegTimestampSrc.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdRegTimestampSrc), -1);
  SwigClassSideTrdRegTimestampSrc.mark = 0;
  SwigClassSideTrdRegTimestampSrc.destroy = (void (*)(void *)) free_FIX_SideTrdRegTimestampSrc;
  SwigClassSideTrdRegTimestampSrc.trackObjects = 0;
  
  SwigClassDeliveryDate.klass = rb_define_class_under(mQuickfix, "DeliveryDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliveryDate, (void *) &SwigClassDeliveryDate);
  rb_define_alloc_func(SwigClassDeliveryDate.klass, _wrap_DeliveryDate_allocate);
  rb_define_method(SwigClassDeliveryDate.klass, "initialize", VALUEFUNC(_wrap_new_DeliveryDate), -1);
  SwigClassDeliveryDate.mark = 0;
  SwigClassDeliveryDate.destroy = (void (*)(void *)) free_FIX_DeliveryDate;
  SwigClassDeliveryDate.trackObjects = 0;
  
  SwigClassEmailType.klass = rb_define_class_under(mQuickfix, "EmailType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EmailType, (void *) &SwigClassEmailType);
  rb_define_alloc_func(SwigClassEmailType.klass, _wrap_EmailType_allocate);
  rb_define_method(SwigClassEmailType.klass, "initialize", VALUEFUNC(_wrap_new_EmailType), -1);
  SwigClassEmailType.mark = 0;
  SwigClassEmailType.destroy = (void (*)(void *)) free_FIX_EmailType;
  SwigClassEmailType.trackObjects = 0;
  
  SwigClassEncodedListExecInst.klass = rb_define_class_under(mQuickfix, "EncodedListExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListExecInst, (void *) &SwigClassEncodedListExecInst);
  rb_define_alloc_func(SwigClassEncodedListExecInst.klass, _wrap_EncodedListExecInst_allocate);
  rb_define_method(SwigClassEncodedListExecInst.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListExecInst), -1);
  SwigClassEncodedListExecInst.mark = 0;
  SwigClassEncodedListExecInst.destroy = (void (*)(void *)) free_FIX_EncodedListExecInst;
  SwigClassEncodedListExecInst.trackObjects = 0;
  
  SwigClassContraTradeTime.klass = rb_define_class_under(mQuickfix, "ContraTradeTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraTradeTime, (void *) &SwigClassContraTradeTime);
  rb_define_alloc_func(SwigClassContraTradeTime.klass, _wrap_ContraTradeTime_allocate);
  rb_define_method(SwigClassContraTradeTime.klass, "initialize", VALUEFUNC(_wrap_new_ContraTradeTime), -1);
  SwigClassContraTradeTime.mark = 0;
  SwigClassContraTradeTime.destroy = (void (*)(void *)) free_FIX_ContraTradeTime;
  SwigClassContraTradeTime.trackObjects = 0;
  
  SwigClassMaturityMonthYearIncrement.klass = rb_define_class_under(mQuickfix, "MaturityMonthYearIncrement", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYearIncrement, (void *) &SwigClassMaturityMonthYearIncrement);
  rb_define_alloc_func(SwigClassMaturityMonthYearIncrement.klass, _wrap_MaturityMonthYearIncrement_allocate);
  rb_define_method(SwigClassMaturityMonthYearIncrement.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYearIncrement), -1);
  SwigClassMaturityMonthYearIncrement.mark = 0;
  SwigClassMaturityMonthYearIncrement.destroy = (void (*)(void *)) free_FIX_MaturityMonthYearIncrement;
  SwigClassMaturityMonthYearIncrement.trackObjects = 0;
  
  SwigClassRootPartyIDSource.klass = rb_define_class_under(mQuickfix, "RootPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartyIDSource, (void *) &SwigClassRootPartyIDSource);
  rb_define_alloc_func(SwigClassRootPartyIDSource.klass, _wrap_RootPartyIDSource_allocate);
  rb_define_method(SwigClassRootPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RootPartyIDSource), -1);
  SwigClassRootPartyIDSource.mark = 0;
  SwigClassRootPartyIDSource.destroy = (void (*)(void *)) free_FIX_RootPartyIDSource;
  SwigClassRootPartyIDSource.trackObjects = 0;
  
  SwigClassUnderlyingCouponPaymentDate.klass = rb_define_class_under(mQuickfix, "UnderlyingCouponPaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate, (void *) &SwigClassUnderlyingCouponPaymentDate);
  rb_define_alloc_func(SwigClassUnderlyingCouponPaymentDate.klass, _wrap_UnderlyingCouponPaymentDate_allocate);
  rb_define_method(SwigClassUnderlyingCouponPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCouponPaymentDate), -1);
  SwigClassUnderlyingCouponPaymentDate.mark = 0;
  SwigClassUnderlyingCouponPaymentDate.destroy = (void (*)(void *)) free_FIX_UnderlyingCouponPaymentDate;
  SwigClassUnderlyingCouponPaymentDate.trackObjects = 0;
  
  SwigClassBidYield.klass = rb_define_class_under(mQuickfix, "BidYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidYield, (void *) &SwigClassBidYield);
  rb_define_alloc_func(SwigClassBidYield.klass, _wrap_BidYield_allocate);
  rb_define_method(SwigClassBidYield.klass, "initialize", VALUEFUNC(_wrap_new_BidYield), -1);
  SwigClassBidYield.mark = 0;
  SwigClassBidYield.destroy = (void (*)(void *)) free_FIX_BidYield;
  SwigClassBidYield.trackObjects = 0;
  
  SwigClassIOIQltyInd.klass = rb_define_class_under(mQuickfix, "IOIQltyInd", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIQltyInd, (void *) &SwigClassIOIQltyInd);
  rb_define_alloc_func(SwigClassIOIQltyInd.klass, _wrap_IOIQltyInd_allocate);
  rb_define_method(SwigClassIOIQltyInd.klass, "initialize", VALUEFUNC(_wrap_new_IOIQltyInd), -1);
  SwigClassIOIQltyInd.mark = 0;
  SwigClassIOIQltyInd.destroy = (void (*)(void *)) free_FIX_IOIQltyInd;
  SwigClassIOIQltyInd.trackObjects = 0;
  
  SwigClassIssuer.klass = rb_define_class_under(mQuickfix, "Issuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Issuer, (void *) &SwigClassIssuer);
  rb_define_alloc_func(SwigClassIssuer.klass, _wrap_Issuer_allocate);
  rb_define_method(SwigClassIssuer.klass, "initialize", VALUEFUNC(_wrap_new_Issuer), -1);
  SwigClassIssuer.mark = 0;
  SwigClassIssuer.destroy = (void (*)(void *)) free_FIX_Issuer;
  SwigClassIssuer.trackObjects = 0;
  
  SwigClassCardNumber.klass = rb_define_class_under(mQuickfix, "CardNumber", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardNumber, (void *) &SwigClassCardNumber);
  rb_define_alloc_func(SwigClassCardNumber.klass, _wrap_CardNumber_allocate);
  rb_define_method(SwigClassCardNumber.klass, "initialize", VALUEFUNC(_wrap_new_CardNumber), -1);
  SwigClassCardNumber.mark = 0;
  SwigClassCardNumber.destroy = (void (*)(void *)) free_FIX_CardNumber;
  SwigClassCardNumber.trackObjects = 0;
  
  SwigClassNoLegStipulations.klass = rb_define_class_under(mQuickfix, "NoLegStipulations", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegStipulations, (void *) &SwigClassNoLegStipulations);
  rb_define_alloc_func(SwigClassNoLegStipulations.klass, _wrap_NoLegStipulations_allocate);
  rb_define_method(SwigClassNoLegStipulations.klass, "initialize", VALUEFUNC(_wrap_new_NoLegStipulations), -1);
  SwigClassNoLegStipulations.mark = 0;
  SwigClassNoLegStipulations.destroy = (void (*)(void *)) free_FIX_NoLegStipulations;
  SwigClassNoLegStipulations.trackObjects = 0;
  
  SwigClassLegSecurityExchange.klass = rb_define_class_under(mQuickfix, "LegSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityExchange, (void *) &SwigClassLegSecurityExchange);
  rb_define_alloc_func(SwigClassLegSecurityExchange.klass, _wrap_LegSecurityExchange_allocate);
  rb_define_method(SwigClassLegSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityExchange), -1);
  SwigClassLegSecurityExchange.mark = 0;
  SwigClassLegSecurityExchange.destroy = (void (*)(void *)) free_FIX_LegSecurityExchange;
  SwigClassLegSecurityExchange.trackObjects = 0;
  
  SwigClassCashOrderQty.klass = rb_define_class_under(mQuickfix, "CashOrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashOrderQty, (void *) &SwigClassCashOrderQty);
  rb_define_alloc_func(SwigClassCashOrderQty.klass, _wrap_CashOrderQty_allocate);
  rb_define_method(SwigClassCashOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_CashOrderQty), -1);
  SwigClassCashOrderQty.mark = 0;
  SwigClassCashOrderQty.destroy = (void (*)(void *)) free_FIX_CashOrderQty;
  SwigClassCashOrderQty.trackObjects = 0;
  
  SwigClassAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "AccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AccruedInterestAmt, (void *) &SwigClassAccruedInterestAmt);
  rb_define_alloc_func(SwigClassAccruedInterestAmt.klass, _wrap_AccruedInterestAmt_allocate);
  rb_define_method(SwigClassAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_AccruedInterestAmt), -1);
  SwigClassAccruedInterestAmt.mark = 0;
  SwigClassAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_AccruedInterestAmt;
  SwigClassAccruedInterestAmt.trackObjects = 0;
  
  SwigClassMDEntrySeller.klass = rb_define_class_under(mQuickfix, "MDEntrySeller", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntrySeller, (void *) &SwigClassMDEntrySeller);
  rb_define_alloc_func(SwigClassMDEntrySeller.klass, _wrap_MDEntrySeller_allocate);
  rb_define_method(SwigClassMDEntrySeller.klass, "initialize", VALUEFUNC(_wrap_new_MDEntrySeller), -1);
  SwigClassMDEntrySeller.mark = 0;
  SwigClassMDEntrySeller.destroy = (void (*)(void *)) free_FIX_MDEntrySeller;
  SwigClassMDEntrySeller.trackObjects = 0;
  
  SwigClassLegPrice.klass = rb_define_class_under(mQuickfix, "LegPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPrice, (void *) &SwigClassLegPrice);
  rb_define_alloc_func(SwigClassLegPrice.klass, _wrap_LegPrice_allocate);
  rb_define_method(SwigClassLegPrice.klass, "initialize", VALUEFUNC(_wrap_new_LegPrice), -1);
  SwigClassLegPrice.mark = 0;
  SwigClassLegPrice.destroy = (void (*)(void *)) free_FIX_LegPrice;
  SwigClassLegPrice.trackObjects = 0;
  
  SwigClassDeliverToCompID.klass = rb_define_class_under(mQuickfix, "DeliverToCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliverToCompID, (void *) &SwigClassDeliverToCompID);
  rb_define_alloc_func(SwigClassDeliverToCompID.klass, _wrap_DeliverToCompID_allocate);
  rb_define_method(SwigClassDeliverToCompID.klass, "initialize", VALUEFUNC(_wrap_new_DeliverToCompID), -1);
  SwigClassDeliverToCompID.mark = 0;
  SwigClassDeliverToCompID.destroy = (void (*)(void *)) free_FIX_DeliverToCompID;
  SwigClassDeliverToCompID.trackObjects = 0;
  
  SwigClassTargetLocationID.klass = rb_define_class_under(mQuickfix, "TargetLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetLocationID, (void *) &SwigClassTargetLocationID);
  rb_define_alloc_func(SwigClassTargetLocationID.klass, _wrap_TargetLocationID_allocate);
  rb_define_method(SwigClassTargetLocationID.klass, "initialize", VALUEFUNC(_wrap_new_TargetLocationID), -1);
  SwigClassTargetLocationID.mark = 0;
  SwigClassTargetLocationID.destroy = (void (*)(void *)) free_FIX_TargetLocationID;
  SwigClassTargetLocationID.trackObjects = 0;
  
  SwigClassOfferForwardPoints2.klass = rb_define_class_under(mQuickfix, "OfferForwardPoints2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferForwardPoints2, (void *) &SwigClassOfferForwardPoints2);
  rb_define_alloc_func(SwigClassOfferForwardPoints2.klass, _wrap_OfferForwardPoints2_allocate);
  rb_define_method(SwigClassOfferForwardPoints2.klass, "initialize", VALUEFUNC(_wrap_new_OfferForwardPoints2), -1);
  SwigClassOfferForwardPoints2.mark = 0;
  SwigClassOfferForwardPoints2.destroy = (void (*)(void *)) free_FIX_OfferForwardPoints2;
  SwigClassOfferForwardPoints2.trackObjects = 0;
  
  SwigClassRatioQty.klass = rb_define_class_under(mQuickfix, "RatioQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RatioQty, (void *) &SwigClassRatioQty);
  rb_define_alloc_func(SwigClassRatioQty.klass, _wrap_RatioQty_allocate);
  rb_define_method(SwigClassRatioQty.klass, "initialize", VALUEFUNC(_wrap_new_RatioQty), -1);
  SwigClassRatioQty.mark = 0;
  SwigClassRatioQty.destroy = (void (*)(void *)) free_FIX_RatioQty;
  SwigClassRatioQty.trackObjects = 0;
  
  SwigClassMultiLegRptTypeReq.klass = rb_define_class_under(mQuickfix, "MultiLegRptTypeReq", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultiLegRptTypeReq, (void *) &SwigClassMultiLegRptTypeReq);
  rb_define_alloc_func(SwigClassMultiLegRptTypeReq.klass, _wrap_MultiLegRptTypeReq_allocate);
  rb_define_method(SwigClassMultiLegRptTypeReq.klass, "initialize", VALUEFUNC(_wrap_new_MultiLegRptTypeReq), -1);
  SwigClassMultiLegRptTypeReq.mark = 0;
  SwigClassMultiLegRptTypeReq.destroy = (void (*)(void *)) free_FIX_MultiLegRptTypeReq;
  SwigClassMultiLegRptTypeReq.trackObjects = 0;
  
  SwigClassAllocAccount.klass = rb_define_class_under(mQuickfix, "AllocAccount", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAccount, (void *) &SwigClassAllocAccount);
  rb_define_alloc_func(SwigClassAllocAccount.klass, _wrap_AllocAccount_allocate);
  rb_define_method(SwigClassAllocAccount.klass, "initialize", VALUEFUNC(_wrap_new_AllocAccount), -1);
  SwigClassAllocAccount.mark = 0;
  SwigClassAllocAccount.destroy = (void (*)(void *)) free_FIX_AllocAccount;
  SwigClassAllocAccount.trackObjects = 0;
  
  SwigClassTotalVolumeTraded.klass = rb_define_class_under(mQuickfix, "TotalVolumeTraded", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalVolumeTraded, (void *) &SwigClassTotalVolumeTraded);
  rb_define_alloc_func(SwigClassTotalVolumeTraded.klass, _wrap_TotalVolumeTraded_allocate);
  rb_define_method(SwigClassTotalVolumeTraded.klass, "initialize", VALUEFUNC(_wrap_new_TotalVolumeTraded), -1);
  SwigClassTotalVolumeTraded.mark = 0;
  SwigClassTotalVolumeTraded.destroy = (void (*)(void *)) free_FIX_TotalVolumeTraded;
  SwigClassTotalVolumeTraded.trackObjects = 0;
  
  SwigClassLinesOfText.klass = rb_define_class_under(mQuickfix, "LinesOfText", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LinesOfText, (void *) &SwigClassLinesOfText);
  rb_define_alloc_func(SwigClassLinesOfText.klass, _wrap_LinesOfText_allocate);
  rb_define_method(SwigClassLinesOfText.klass, "initialize", VALUEFUNC(_wrap_new_LinesOfText), -1);
  SwigClassLinesOfText.mark = 0;
  SwigClassLinesOfText.destroy = (void (*)(void *)) free_FIX_LinesOfText;
  SwigClassLinesOfText.trackObjects = 0;
  
  SwigClassAccountType.klass = rb_define_class_under(mQuickfix, "AccountType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AccountType, (void *) &SwigClassAccountType);
  rb_define_alloc_func(SwigClassAccountType.klass, _wrap_AccountType_allocate);
  rb_define_method(SwigClassAccountType.klass, "initialize", VALUEFUNC(_wrap_new_AccountType), -1);
  SwigClassAccountType.mark = 0;
  SwigClassAccountType.destroy = (void (*)(void *)) free_FIX_AccountType;
  SwigClassAccountType.trackObjects = 0;
  
  SwigClassMDEntryPositionNo.klass = rb_define_class_under(mQuickfix, "MDEntryPositionNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryPositionNo, (void *) &SwigClassMDEntryPositionNo);
  rb_define_alloc_func(SwigClassMDEntryPositionNo.klass, _wrap_MDEntryPositionNo_allocate);
  rb_define_method(SwigClassMDEntryPositionNo.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryPositionNo), -1);
  SwigClassMDEntryPositionNo.mark = 0;
  SwigClassMDEntryPositionNo.destroy = (void (*)(void *)) free_FIX_MDEntryPositionNo;
  SwigClassMDEntryPositionNo.trackObjects = 0;
  
  SwigClassHaltReasonInt.klass = rb_define_class_under(mQuickfix, "HaltReasonInt", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HaltReasonInt, (void *) &SwigClassHaltReasonInt);
  rb_define_alloc_func(SwigClassHaltReasonInt.klass, _wrap_HaltReasonInt_allocate);
  rb_define_method(SwigClassHaltReasonInt.klass, "initialize", VALUEFUNC(_wrap_new_HaltReasonInt), -1);
  SwigClassHaltReasonInt.mark = 0;
  SwigClassHaltReasonInt.destroy = (void (*)(void *)) free_FIX_HaltReasonInt;
  SwigClassHaltReasonInt.trackObjects = 0;
  
  SwigClassFutSettDate.klass = rb_define_class_under(mQuickfix, "FutSettDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FutSettDate, (void *) &SwigClassFutSettDate);
  rb_define_alloc_func(SwigClassFutSettDate.klass, _wrap_FutSettDate_allocate);
  rb_define_method(SwigClassFutSettDate.klass, "initialize", VALUEFUNC(_wrap_new_FutSettDate), -1);
  SwigClassFutSettDate.mark = 0;
  SwigClassFutSettDate.destroy = (void (*)(void *)) free_FIX_FutSettDate;
  SwigClassFutSettDate.trackObjects = 0;
  
  SwigClassSecurityDesc.klass = rb_define_class_under(mQuickfix, "SecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityDesc, (void *) &SwigClassSecurityDesc);
  rb_define_alloc_func(SwigClassSecurityDesc.klass, _wrap_SecurityDesc_allocate);
  rb_define_method(SwigClassSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_SecurityDesc), -1);
  SwigClassSecurityDesc.mark = 0;
  SwigClassSecurityDesc.destroy = (void (*)(void *)) free_FIX_SecurityDesc;
  SwigClassSecurityDesc.trackObjects = 0;
  
  SwigClassMinQty.klass = rb_define_class_under(mQuickfix, "MinQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinQty, (void *) &SwigClassMinQty);
  rb_define_alloc_func(SwigClassMinQty.klass, _wrap_MinQty_allocate);
  rb_define_method(SwigClassMinQty.klass, "initialize", VALUEFUNC(_wrap_new_MinQty), -1);
  SwigClassMinQty.mark = 0;
  SwigClassMinQty.destroy = (void (*)(void *)) free_FIX_MinQty;
  SwigClassMinQty.trackObjects = 0;
  
  SwigClassSettlCurrency.klass = rb_define_class_under(mQuickfix, "SettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrency, (void *) &SwigClassSettlCurrency);
  rb_define_alloc_func(SwigClassSettlCurrency.klass, _wrap_SettlCurrency_allocate);
  rb_define_method(SwigClassSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrency), -1);
  SwigClassSettlCurrency.mark = 0;
  SwigClassSettlCurrency.destroy = (void (*)(void *)) free_FIX_SettlCurrency;
  SwigClassSettlCurrency.trackObjects = 0;
  
  SwigClassPegOffsetValue.klass = rb_define_class_under(mQuickfix, "PegOffsetValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegOffsetValue, (void *) &SwigClassPegOffsetValue);
  rb_define_alloc_func(SwigClassPegOffsetValue.klass, _wrap_PegOffsetValue_allocate);
  rb_define_method(SwigClassPegOffsetValue.klass, "initialize", VALUEFUNC(_wrap_new_PegOffsetValue), -1);
  SwigClassPegOffsetValue.mark = 0;
  SwigClassPegOffsetValue.destroy = (void (*)(void *)) free_FIX_PegOffsetValue;
  SwigClassPegOffsetValue.trackObjects = 0;
  
  SwigClassDerivativeSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource, (void *) &SwigClassDerivativeSecurityAltIDSource);
  rb_define_alloc_func(SwigClassDerivativeSecurityAltIDSource.klass, _wrap_DerivativeSecurityAltIDSource_allocate);
  rb_define_method(SwigClassDerivativeSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityAltIDSource), -1);
  SwigClassDerivativeSecurityAltIDSource.mark = 0;
  SwigClassDerivativeSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityAltIDSource;
  SwigClassDerivativeSecurityAltIDSource.trackObjects = 0;
  
  SwigClassNoSettlPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoSettlPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlPartySubIDs, (void *) &SwigClassNoSettlPartySubIDs);
  rb_define_alloc_func(SwigClassNoSettlPartySubIDs.klass, _wrap_NoSettlPartySubIDs_allocate);
  rb_define_method(SwigClassNoSettlPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlPartySubIDs), -1);
  SwigClassNoSettlPartySubIDs.mark = 0;
  SwigClassNoSettlPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoSettlPartySubIDs;
  SwigClassNoSettlPartySubIDs.trackObjects = 0;
  
  SwigClassAllocReportID.klass = rb_define_class_under(mQuickfix, "AllocReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocReportID, (void *) &SwigClassAllocReportID);
  rb_define_alloc_func(SwigClassAllocReportID.klass, _wrap_AllocReportID_allocate);
  rb_define_method(SwigClassAllocReportID.klass, "initialize", VALUEFUNC(_wrap_new_AllocReportID), -1);
  SwigClassAllocReportID.mark = 0;
  SwigClassAllocReportID.destroy = (void (*)(void *)) free_FIX_AllocReportID;
  SwigClassAllocReportID.trackObjects = 0;
  
  SwigClassLegCFICode.klass = rb_define_class_under(mQuickfix, "LegCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCFICode, (void *) &SwigClassLegCFICode);
  rb_define_alloc_func(SwigClassLegCFICode.klass, _wrap_LegCFICode_allocate);
  rb_define_method(SwigClassLegCFICode.klass, "initialize", VALUEFUNC(_wrap_new_LegCFICode), -1);
  SwigClassLegCFICode.mark = 0;
  SwigClassLegCFICode.destroy = (void (*)(void *)) free_FIX_LegCFICode;
  SwigClassLegCFICode.trackObjects = 0;
  
  SwigClassLegFutSettDate.klass = rb_define_class_under(mQuickfix, "LegFutSettDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegFutSettDate, (void *) &SwigClassLegFutSettDate);
  rb_define_alloc_func(SwigClassLegFutSettDate.klass, _wrap_LegFutSettDate_allocate);
  rb_define_method(SwigClassLegFutSettDate.klass, "initialize", VALUEFUNC(_wrap_new_LegFutSettDate), -1);
  SwigClassLegFutSettDate.mark = 0;
  SwigClassLegFutSettDate.destroy = (void (*)(void *)) free_FIX_LegFutSettDate;
  SwigClassLegFutSettDate.trackObjects = 0;
  
  SwigClassLegBenchmarkCurveName.klass = rb_define_class_under(mQuickfix, "LegBenchmarkCurveName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkCurveName, (void *) &SwigClassLegBenchmarkCurveName);
  rb_define_alloc_func(SwigClassLegBenchmarkCurveName.klass, _wrap_LegBenchmarkCurveName_allocate);
  rb_define_method(SwigClassLegBenchmarkCurveName.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkCurveName), -1);
  SwigClassLegBenchmarkCurveName.mark = 0;
  SwigClassLegBenchmarkCurveName.destroy = (void (*)(void *)) free_FIX_LegBenchmarkCurveName;
  SwigClassLegBenchmarkCurveName.trackObjects = 0;
  
  SwigClassClearingFeeIndicator.klass = rb_define_class_under(mQuickfix, "ClearingFeeIndicator", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingFeeIndicator, (void *) &SwigClassClearingFeeIndicator);
  rb_define_alloc_func(SwigClassClearingFeeIndicator.klass, _wrap_ClearingFeeIndicator_allocate);
  rb_define_method(SwigClassClearingFeeIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ClearingFeeIndicator), -1);
  SwigClassClearingFeeIndicator.mark = 0;
  SwigClassClearingFeeIndicator.destroy = (void (*)(void *)) free_FIX_ClearingFeeIndicator;
  SwigClassClearingFeeIndicator.trackObjects = 0;
  
  SwigClassBrokerOfCredit.klass = rb_define_class_under(mQuickfix, "BrokerOfCredit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BrokerOfCredit, (void *) &SwigClassBrokerOfCredit);
  rb_define_alloc_func(SwigClassBrokerOfCredit.klass, _wrap_BrokerOfCredit_allocate);
  rb_define_method(SwigClassBrokerOfCredit.klass, "initialize", VALUEFUNC(_wrap_new_BrokerOfCredit), -1);
  SwigClassBrokerOfCredit.mark = 0;
  SwigClassBrokerOfCredit.destroy = (void (*)(void *)) free_FIX_BrokerOfCredit;
  SwigClassBrokerOfCredit.trackObjects = 0;
  
  SwigClassSecurityListRefID.klass = rb_define_class_under(mQuickfix, "SecurityListRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListRefID, (void *) &SwigClassSecurityListRefID);
  rb_define_alloc_func(SwigClassSecurityListRefID.klass, _wrap_SecurityListRefID_allocate);
  rb_define_method(SwigClassSecurityListRefID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListRefID), -1);
  SwigClassSecurityListRefID.mark = 0;
  SwigClassSecurityListRefID.destroy = (void (*)(void *)) free_FIX_SecurityListRefID;
  SwigClassSecurityListRefID.trackObjects = 0;
  
  SwigClassUnderlyingLegMaturityTime.klass = rb_define_class_under(mQuickfix, "UnderlyingLegMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityTime, (void *) &SwigClassUnderlyingLegMaturityTime);
  rb_define_alloc_func(SwigClassUnderlyingLegMaturityTime.klass, _wrap_UnderlyingLegMaturityTime_allocate);
  rb_define_method(SwigClassUnderlyingLegMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegMaturityTime), -1);
  SwigClassUnderlyingLegMaturityTime.mark = 0;
  SwigClassUnderlyingLegMaturityTime.destroy = (void (*)(void *)) free_FIX_UnderlyingLegMaturityTime;
  SwigClassUnderlyingLegMaturityTime.trackObjects = 0;
  
  SwigClassNestedPartySubIDType.klass = rb_define_class_under(mQuickfix, "NestedPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartySubIDType, (void *) &SwigClassNestedPartySubIDType);
  rb_define_alloc_func(SwigClassNestedPartySubIDType.klass, _wrap_NestedPartySubIDType_allocate);
  rb_define_method(SwigClassNestedPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartySubIDType), -1);
  SwigClassNestedPartySubIDType.mark = 0;
  SwigClassNestedPartySubIDType.destroy = (void (*)(void *)) free_FIX_NestedPartySubIDType;
  SwigClassNestedPartySubIDType.trackObjects = 0;
  
  SwigClassBidType.klass = rb_define_class_under(mQuickfix, "BidType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidType, (void *) &SwigClassBidType);
  rb_define_alloc_func(SwigClassBidType.klass, _wrap_BidType_allocate);
  rb_define_method(SwigClassBidType.klass, "initialize", VALUEFUNC(_wrap_new_BidType), -1);
  SwigClassBidType.mark = 0;
  SwigClassBidType.destroy = (void (*)(void *)) free_FIX_BidType;
  SwigClassBidType.trackObjects = 0;
  
  SwigClassMDEntryRefID.klass = rb_define_class_under(mQuickfix, "MDEntryRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryRefID, (void *) &SwigClassMDEntryRefID);
  rb_define_alloc_func(SwigClassMDEntryRefID.klass, _wrap_MDEntryRefID_allocate);
  rb_define_method(SwigClassMDEntryRefID.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryRefID), -1);
  SwigClassMDEntryRefID.mark = 0;
  SwigClassMDEntryRefID.destroy = (void (*)(void *)) free_FIX_MDEntryRefID;
  SwigClassMDEntryRefID.trackObjects = 0;
  
  SwigClassUnderlyingUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "UnderlyingUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty, (void *) &SwigClassUnderlyingUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassUnderlyingUnitOfMeasureQty.klass, _wrap_UnderlyingUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassUnderlyingUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingUnitOfMeasureQty), -1);
  SwigClassUnderlyingUnitOfMeasureQty.mark = 0;
  SwigClassUnderlyingUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_UnderlyingUnitOfMeasureQty;
  SwigClassUnderlyingUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassUnderlyingLegMaturityDate.klass = rb_define_class_under(mQuickfix, "UnderlyingLegMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityDate, (void *) &SwigClassUnderlyingLegMaturityDate);
  rb_define_alloc_func(SwigClassUnderlyingLegMaturityDate.klass, _wrap_UnderlyingLegMaturityDate_allocate);
  rb_define_method(SwigClassUnderlyingLegMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegMaturityDate), -1);
  SwigClassUnderlyingLegMaturityDate.mark = 0;
  SwigClassUnderlyingLegMaturityDate.destroy = (void (*)(void *)) free_FIX_UnderlyingLegMaturityDate;
  SwigClassUnderlyingLegMaturityDate.trackObjects = 0;
  
  SwigClassStartTickPriceRange.klass = rb_define_class_under(mQuickfix, "StartTickPriceRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartTickPriceRange, (void *) &SwigClassStartTickPriceRange);
  rb_define_alloc_func(SwigClassStartTickPriceRange.klass, _wrap_StartTickPriceRange_allocate);
  rb_define_method(SwigClassStartTickPriceRange.klass, "initialize", VALUEFUNC(_wrap_new_StartTickPriceRange), -1);
  SwigClassStartTickPriceRange.mark = 0;
  SwigClassStartTickPriceRange.destroy = (void (*)(void *)) free_FIX_StartTickPriceRange;
  SwigClassStartTickPriceRange.trackObjects = 0;
  
  SwigClassLegContractSettlMonth.klass = rb_define_class_under(mQuickfix, "LegContractSettlMonth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegContractSettlMonth, (void *) &SwigClassLegContractSettlMonth);
  rb_define_alloc_func(SwigClassLegContractSettlMonth.klass, _wrap_LegContractSettlMonth_allocate);
  rb_define_method(SwigClassLegContractSettlMonth.klass, "initialize", VALUEFUNC(_wrap_new_LegContractSettlMonth), -1);
  SwigClassLegContractSettlMonth.mark = 0;
  SwigClassLegContractSettlMonth.destroy = (void (*)(void *)) free_FIX_LegContractSettlMonth;
  SwigClassLegContractSettlMonth.trackObjects = 0;
  
  SwigClassUnderlyingSecurityDesc.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityDesc, (void *) &SwigClassUnderlyingSecurityDesc);
  rb_define_alloc_func(SwigClassUnderlyingSecurityDesc.klass, _wrap_UnderlyingSecurityDesc_allocate);
  rb_define_method(SwigClassUnderlyingSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityDesc), -1);
  SwigClassUnderlyingSecurityDesc.mark = 0;
  SwigClassUnderlyingSecurityDesc.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityDesc;
  SwigClassUnderlyingSecurityDesc.trackObjects = 0;
  
  SwigClassCashDistribPayRef.klass = rb_define_class_under(mQuickfix, "CashDistribPayRef", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribPayRef, (void *) &SwigClassCashDistribPayRef);
  rb_define_alloc_func(SwigClassCashDistribPayRef.klass, _wrap_CashDistribPayRef_allocate);
  rb_define_method(SwigClassCashDistribPayRef.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribPayRef), -1);
  SwigClassCashDistribPayRef.mark = 0;
  SwigClassCashDistribPayRef.destroy = (void (*)(void *)) free_FIX_CashDistribPayRef;
  SwigClassCashDistribPayRef.trackObjects = 0;
  
  SwigClassQuotePriceType.klass = rb_define_class_under(mQuickfix, "QuotePriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuotePriceType, (void *) &SwigClassQuotePriceType);
  rb_define_alloc_func(SwigClassQuotePriceType.klass, _wrap_QuotePriceType_allocate);
  rb_define_method(SwigClassQuotePriceType.klass, "initialize", VALUEFUNC(_wrap_new_QuotePriceType), -1);
  SwigClassQuotePriceType.mark = 0;
  SwigClassQuotePriceType.destroy = (void (*)(void *)) free_FIX_QuotePriceType;
  SwigClassQuotePriceType.trackObjects = 0;
  
  SwigClassEncodedAllocText.klass = rb_define_class_under(mQuickfix, "EncodedAllocText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedAllocText, (void *) &SwigClassEncodedAllocText);
  rb_define_alloc_func(SwigClassEncodedAllocText.klass, _wrap_EncodedAllocText_allocate);
  rb_define_method(SwigClassEncodedAllocText.klass, "initialize", VALUEFUNC(_wrap_new_EncodedAllocText), -1);
  SwigClassEncodedAllocText.mark = 0;
  SwigClassEncodedAllocText.destroy = (void (*)(void *)) free_FIX_EncodedAllocText;
  SwigClassEncodedAllocText.trackObjects = 0;
  
  SwigClassUnderlyingMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear, (void *) &SwigClassUnderlyingMaturityMonthYear);
  rb_define_alloc_func(SwigClassUnderlyingMaturityMonthYear.klass, _wrap_UnderlyingMaturityMonthYear_allocate);
  rb_define_method(SwigClassUnderlyingMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityMonthYear), -1);
  SwigClassUnderlyingMaturityMonthYear.mark = 0;
  SwigClassUnderlyingMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityMonthYear;
  SwigClassUnderlyingMaturityMonthYear.trackObjects = 0;
  
  SwigClassUnderlyingOriginalNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "UnderlyingOriginalNotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, (void *) &SwigClassUnderlyingOriginalNotionalPercentageOutstanding);
  rb_define_alloc_func(SwigClassUnderlyingOriginalNotionalPercentageOutstanding.klass, _wrap_UnderlyingOriginalNotionalPercentageOutstanding_allocate);
  rb_define_method(SwigClassUnderlyingOriginalNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding), -1);
  SwigClassUnderlyingOriginalNotionalPercentageOutstanding.mark = 0;
  SwigClassUnderlyingOriginalNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_UnderlyingOriginalNotionalPercentageOutstanding;
  SwigClassUnderlyingOriginalNotionalPercentageOutstanding.trackObjects = 0;
  
  SwigClassMultilegPriceMethod.klass = rb_define_class_under(mQuickfix, "MultilegPriceMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultilegPriceMethod, (void *) &SwigClassMultilegPriceMethod);
  rb_define_alloc_func(SwigClassMultilegPriceMethod.klass, _wrap_MultilegPriceMethod_allocate);
  rb_define_method(SwigClassMultilegPriceMethod.klass, "initialize", VALUEFUNC(_wrap_new_MultilegPriceMethod), -1);
  SwigClassMultilegPriceMethod.mark = 0;
  SwigClassMultilegPriceMethod.destroy = (void (*)(void *)) free_FIX_MultilegPriceMethod;
  SwigClassMultilegPriceMethod.trackObjects = 0;
  
  SwigClassTotNoFills.klass = rb_define_class_under(mQuickfix, "TotNoFills", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoFills, (void *) &SwigClassTotNoFills);
  rb_define_alloc_func(SwigClassTotNoFills.klass, _wrap_TotNoFills_allocate);
  rb_define_method(SwigClassTotNoFills.klass, "initialize", VALUEFUNC(_wrap_new_TotNoFills), -1);
  SwigClassTotNoFills.mark = 0;
  SwigClassTotNoFills.destroy = (void (*)(void *)) free_FIX_TotNoFills;
  SwigClassTotNoFills.trackObjects = 0;
  
  SwigClassDerivativeSettleOnOpenFlag.klass = rb_define_class_under(mQuickfix, "DerivativeSettleOnOpenFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag, (void *) &SwigClassDerivativeSettleOnOpenFlag);
  rb_define_alloc_func(SwigClassDerivativeSettleOnOpenFlag.klass, _wrap_DerivativeSettleOnOpenFlag_allocate);
  rb_define_method(SwigClassDerivativeSettleOnOpenFlag.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSettleOnOpenFlag), -1);
  SwigClassDerivativeSettleOnOpenFlag.mark = 0;
  SwigClassDerivativeSettleOnOpenFlag.destroy = (void (*)(void *)) free_FIX_DerivativeSettleOnOpenFlag;
  SwigClassDerivativeSettleOnOpenFlag.trackObjects = 0;
  
  SwigClassUnderlyingRepurchaseTerm.klass = rb_define_class_under(mQuickfix, "UnderlyingRepurchaseTerm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm, (void *) &SwigClassUnderlyingRepurchaseTerm);
  rb_define_alloc_func(SwigClassUnderlyingRepurchaseTerm.klass, _wrap_UnderlyingRepurchaseTerm_allocate);
  rb_define_method(SwigClassUnderlyingRepurchaseTerm.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRepurchaseTerm), -1);
  SwigClassUnderlyingRepurchaseTerm.mark = 0;
  SwigClassUnderlyingRepurchaseTerm.destroy = (void (*)(void *)) free_FIX_UnderlyingRepurchaseTerm;
  SwigClassUnderlyingRepurchaseTerm.trackObjects = 0;
  
  SwigClassDerivativeCountryOfIssue.klass = rb_define_class_under(mQuickfix, "DerivativeCountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeCountryOfIssue, (void *) &SwigClassDerivativeCountryOfIssue);
  rb_define_alloc_func(SwigClassDerivativeCountryOfIssue.klass, _wrap_DerivativeCountryOfIssue_allocate);
  rb_define_method(SwigClassDerivativeCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeCountryOfIssue), -1);
  SwigClassDerivativeCountryOfIssue.mark = 0;
  SwigClassDerivativeCountryOfIssue.destroy = (void (*)(void *)) free_FIX_DerivativeCountryOfIssue;
  SwigClassDerivativeCountryOfIssue.trackObjects = 0;
  
  SwigClassListMethod.klass = rb_define_class_under(mQuickfix, "ListMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListMethod, (void *) &SwigClassListMethod);
  rb_define_alloc_func(SwigClassListMethod.klass, _wrap_ListMethod_allocate);
  rb_define_method(SwigClassListMethod.klass, "initialize", VALUEFUNC(_wrap_new_ListMethod), -1);
  SwigClassListMethod.mark = 0;
  SwigClassListMethod.destroy = (void (*)(void *)) free_FIX_ListMethod;
  SwigClassListMethod.trackObjects = 0;
  
  SwigClassUnderlyingCPProgram.klass = rb_define_class_under(mQuickfix, "UnderlyingCPProgram", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCPProgram, (void *) &SwigClassUnderlyingCPProgram);
  rb_define_alloc_func(SwigClassUnderlyingCPProgram.klass, _wrap_UnderlyingCPProgram_allocate);
  rb_define_method(SwigClassUnderlyingCPProgram.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCPProgram), -1);
  SwigClassUnderlyingCPProgram.mark = 0;
  SwigClassUnderlyingCPProgram.destroy = (void (*)(void *)) free_FIX_UnderlyingCPProgram;
  SwigClassUnderlyingCPProgram.trackObjects = 0;
  
  SwigClassPriceDelta.klass = rb_define_class_under(mQuickfix, "PriceDelta", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceDelta, (void *) &SwigClassPriceDelta);
  rb_define_alloc_func(SwigClassPriceDelta.klass, _wrap_PriceDelta_allocate);
  rb_define_method(SwigClassPriceDelta.klass, "initialize", VALUEFUNC(_wrap_new_PriceDelta), -1);
  SwigClassPriceDelta.mark = 0;
  SwigClassPriceDelta.destroy = (void (*)(void *)) free_FIX_PriceDelta;
  SwigClassPriceDelta.trackObjects = 0;
  
  SwigClassRefSeqNum.klass = rb_define_class_under(mQuickfix, "RefSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefSeqNum, (void *) &SwigClassRefSeqNum);
  rb_define_alloc_func(SwigClassRefSeqNum.klass, _wrap_RefSeqNum_allocate);
  rb_define_method(SwigClassRefSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_RefSeqNum), -1);
  SwigClassRefSeqNum.mark = 0;
  SwigClassRefSeqNum.destroy = (void (*)(void *)) free_FIX_RefSeqNum;
  SwigClassRefSeqNum.trackObjects = 0;
  
  SwigClassAutoAcceptIndicator.klass = rb_define_class_under(mQuickfix, "AutoAcceptIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AutoAcceptIndicator, (void *) &SwigClassAutoAcceptIndicator);
  rb_define_alloc_func(SwigClassAutoAcceptIndicator.klass, _wrap_AutoAcceptIndicator_allocate);
  rb_define_method(SwigClassAutoAcceptIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AutoAcceptIndicator), -1);
  SwigClassAutoAcceptIndicator.mark = 0;
  SwigClassAutoAcceptIndicator.destroy = (void (*)(void *)) free_FIX_AutoAcceptIndicator;
  SwigClassAutoAcceptIndicator.trackObjects = 0;
  
  SwigClassMDImplicitDelete.klass = rb_define_class_under(mQuickfix, "MDImplicitDelete", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDImplicitDelete, (void *) &SwigClassMDImplicitDelete);
  rb_define_alloc_func(SwigClassMDImplicitDelete.klass, _wrap_MDImplicitDelete_allocate);
  rb_define_method(SwigClassMDImplicitDelete.klass, "initialize", VALUEFUNC(_wrap_new_MDImplicitDelete), -1);
  SwigClassMDImplicitDelete.mark = 0;
  SwigClassMDImplicitDelete.destroy = (void (*)(void *)) free_FIX_MDImplicitDelete;
  SwigClassMDImplicitDelete.trackObjects = 0;
  
  SwigClassNoStipulations.klass = rb_define_class_under(mQuickfix, "NoStipulations", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStipulations, (void *) &SwigClassNoStipulations);
  rb_define_alloc_func(SwigClassNoStipulations.klass, _wrap_NoStipulations_allocate);
  rb_define_method(SwigClassNoStipulations.klass, "initialize", VALUEFUNC(_wrap_new_NoStipulations), -1);
  SwigClassNoStipulations.mark = 0;
  SwigClassNoStipulations.destroy = (void (*)(void *)) free_FIX_NoStipulations;
  SwigClassNoStipulations.trackObjects = 0;
  
  SwigClassClearingBusinessDate.klass = rb_define_class_under(mQuickfix, "ClearingBusinessDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingBusinessDate, (void *) &SwigClassClearingBusinessDate);
  rb_define_alloc_func(SwigClassClearingBusinessDate.klass, _wrap_ClearingBusinessDate_allocate);
  rb_define_method(SwigClassClearingBusinessDate.klass, "initialize", VALUEFUNC(_wrap_new_ClearingBusinessDate), -1);
  SwigClassClearingBusinessDate.mark = 0;
  SwigClassClearingBusinessDate.destroy = (void (*)(void *)) free_FIX_ClearingBusinessDate;
  SwigClassClearingBusinessDate.trackObjects = 0;
  
  SwigClassLocationID.klass = rb_define_class_under(mQuickfix, "LocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LocationID, (void *) &SwigClassLocationID);
  rb_define_alloc_func(SwigClassLocationID.klass, _wrap_LocationID_allocate);
  rb_define_method(SwigClassLocationID.klass, "initialize", VALUEFUNC(_wrap_new_LocationID), -1);
  SwigClassLocationID.mark = 0;
  SwigClassLocationID.destroy = (void (*)(void *)) free_FIX_LocationID;
  SwigClassLocationID.trackObjects = 0;
  
  SwigClassCurrency.klass = rb_define_class_under(mQuickfix, "Currency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Currency, (void *) &SwigClassCurrency);
  rb_define_alloc_func(SwigClassCurrency.klass, _wrap_Currency_allocate);
  rb_define_method(SwigClassCurrency.klass, "initialize", VALUEFUNC(_wrap_new_Currency), -1);
  SwigClassCurrency.mark = 0;
  SwigClassCurrency.destroy = (void (*)(void *)) free_FIX_Currency;
  SwigClassCurrency.trackObjects = 0;
  
  SwigClassRoutingType.klass = rb_define_class_under(mQuickfix, "RoutingType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoutingType, (void *) &SwigClassRoutingType);
  rb_define_alloc_func(SwigClassRoutingType.klass, _wrap_RoutingType_allocate);
  rb_define_method(SwigClassRoutingType.klass, "initialize", VALUEFUNC(_wrap_new_RoutingType), -1);
  SwigClassRoutingType.mark = 0;
  SwigClassRoutingType.destroy = (void (*)(void *)) free_FIX_RoutingType;
  SwigClassRoutingType.trackObjects = 0;
  
  SwigClassUnderlyingStrikePrice.klass = rb_define_class_under(mQuickfix, "UnderlyingStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStrikePrice, (void *) &SwigClassUnderlyingStrikePrice);
  rb_define_alloc_func(SwigClassUnderlyingStrikePrice.klass, _wrap_UnderlyingStrikePrice_allocate);
  rb_define_method(SwigClassUnderlyingStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStrikePrice), -1);
  SwigClassUnderlyingStrikePrice.mark = 0;
  SwigClassUnderlyingStrikePrice.destroy = (void (*)(void *)) free_FIX_UnderlyingStrikePrice;
  SwigClassUnderlyingStrikePrice.trackObjects = 0;
  
  SwigClassBidTradeType.klass = rb_define_class_under(mQuickfix, "BidTradeType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidTradeType, (void *) &SwigClassBidTradeType);
  rb_define_alloc_func(SwigClassBidTradeType.klass, _wrap_BidTradeType_allocate);
  rb_define_method(SwigClassBidTradeType.klass, "initialize", VALUEFUNC(_wrap_new_BidTradeType), -1);
  SwigClassBidTradeType.mark = 0;
  SwigClassBidTradeType.destroy = (void (*)(void *)) free_FIX_BidTradeType;
  SwigClassBidTradeType.trackObjects = 0;
  
  SwigClassUnderlyingAttachmentPoint.klass = rb_define_class_under(mQuickfix, "UnderlyingAttachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingAttachmentPoint, (void *) &SwigClassUnderlyingAttachmentPoint);
  rb_define_alloc_func(SwigClassUnderlyingAttachmentPoint.klass, _wrap_UnderlyingAttachmentPoint_allocate);
  rb_define_method(SwigClassUnderlyingAttachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingAttachmentPoint), -1);
  SwigClassUnderlyingAttachmentPoint.mark = 0;
  SwigClassUnderlyingAttachmentPoint.destroy = (void (*)(void *)) free_FIX_UnderlyingAttachmentPoint;
  SwigClassUnderlyingAttachmentPoint.trackObjects = 0;
  
  SwigClassTotNoRejQuotes.klass = rb_define_class_under(mQuickfix, "TotNoRejQuotes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoRejQuotes, (void *) &SwigClassTotNoRejQuotes);
  rb_define_alloc_func(SwigClassTotNoRejQuotes.klass, _wrap_TotNoRejQuotes_allocate);
  rb_define_method(SwigClassTotNoRejQuotes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoRejQuotes), -1);
  SwigClassTotNoRejQuotes.mark = 0;
  SwigClassTotNoRejQuotes.destroy = (void (*)(void *)) free_FIX_TotNoRejQuotes;
  SwigClassTotNoRejQuotes.trackObjects = 0;
  
  SwigClassOrdStatusReqID.klass = rb_define_class_under(mQuickfix, "OrdStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdStatusReqID, (void *) &SwigClassOrdStatusReqID);
  rb_define_alloc_func(SwigClassOrdStatusReqID.klass, _wrap_OrdStatusReqID_allocate);
  rb_define_method(SwigClassOrdStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_OrdStatusReqID), -1);
  SwigClassOrdStatusReqID.mark = 0;
  SwigClassOrdStatusReqID.destroy = (void (*)(void *)) free_FIX_OrdStatusReqID;
  SwigClassOrdStatusReqID.trackObjects = 0;
  
  SwigClassSenderCompID.klass = rb_define_class_under(mQuickfix, "SenderCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SenderCompID, (void *) &SwigClassSenderCompID);
  rb_define_alloc_func(SwigClassSenderCompID.klass, _wrap_SenderCompID_allocate);
  rb_define_method(SwigClassSenderCompID.klass, "initialize", VALUEFUNC(_wrap_new_SenderCompID), -1);
  SwigClassSenderCompID.mark = 0;
  SwigClassSenderCompID.destroy = (void (*)(void *)) free_FIX_SenderCompID;
  SwigClassSenderCompID.trackObjects = 0;
  
  SwigClassOrdRejReason.klass = rb_define_class_under(mQuickfix, "OrdRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdRejReason, (void *) &SwigClassOrdRejReason);
  rb_define_alloc_func(SwigClassOrdRejReason.klass, _wrap_OrdRejReason_allocate);
  rb_define_method(SwigClassOrdRejReason.klass, "initialize", VALUEFUNC(_wrap_new_OrdRejReason), -1);
  SwigClassOrdRejReason.mark = 0;
  SwigClassOrdRejReason.destroy = (void (*)(void *)) free_FIX_OrdRejReason;
  SwigClassOrdRejReason.trackObjects = 0;
  
  SwigClassMaturityMonthYearIncrementUnits.klass = rb_define_class_under(mQuickfix, "MaturityMonthYearIncrementUnits", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits, (void *) &SwigClassMaturityMonthYearIncrementUnits);
  rb_define_alloc_func(SwigClassMaturityMonthYearIncrementUnits.klass, _wrap_MaturityMonthYearIncrementUnits_allocate);
  rb_define_method(SwigClassMaturityMonthYearIncrementUnits.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYearIncrementUnits), -1);
  SwigClassMaturityMonthYearIncrementUnits.mark = 0;
  SwigClassMaturityMonthYearIncrementUnits.destroy = (void (*)(void *)) free_FIX_MaturityMonthYearIncrementUnits;
  SwigClassMaturityMonthYearIncrementUnits.trackObjects = 0;
  
  SwigClassDisplayWhen.klass = rb_define_class_under(mQuickfix, "DisplayWhen", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayWhen, (void *) &SwigClassDisplayWhen);
  rb_define_alloc_func(SwigClassDisplayWhen.klass, _wrap_DisplayWhen_allocate);
  rb_define_method(SwigClassDisplayWhen.klass, "initialize", VALUEFUNC(_wrap_new_DisplayWhen), -1);
  SwigClassDisplayWhen.mark = 0;
  SwigClassDisplayWhen.destroy = (void (*)(void *)) free_FIX_DisplayWhen;
  SwigClassDisplayWhen.trackObjects = 0;
  
  SwigClassApplQueueAction.klass = rb_define_class_under(mQuickfix, "ApplQueueAction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueAction, (void *) &SwigClassApplQueueAction);
  rb_define_alloc_func(SwigClassApplQueueAction.klass, _wrap_ApplQueueAction_allocate);
  rb_define_method(SwigClassApplQueueAction.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueAction), -1);
  SwigClassApplQueueAction.mark = 0;
  SwigClassApplQueueAction.destroy = (void (*)(void *)) free_FIX_ApplQueueAction;
  SwigClassApplQueueAction.trackObjects = 0;
  
  SwigClassRegistTransType.klass = rb_define_class_under(mQuickfix, "RegistTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistTransType, (void *) &SwigClassRegistTransType);
  rb_define_alloc_func(SwigClassRegistTransType.klass, _wrap_RegistTransType_allocate);
  rb_define_method(SwigClassRegistTransType.klass, "initialize", VALUEFUNC(_wrap_new_RegistTransType), -1);
  SwigClassRegistTransType.mark = 0;
  SwigClassRegistTransType.destroy = (void (*)(void *)) free_FIX_RegistTransType;
  SwigClassRegistTransType.trackObjects = 0;
  
  SwigClassPaymentRemitterID.klass = rb_define_class_under(mQuickfix, "PaymentRemitterID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentRemitterID, (void *) &SwigClassPaymentRemitterID);
  rb_define_alloc_func(SwigClassPaymentRemitterID.klass, _wrap_PaymentRemitterID_allocate);
  rb_define_method(SwigClassPaymentRemitterID.klass, "initialize", VALUEFUNC(_wrap_new_PaymentRemitterID), -1);
  SwigClassPaymentRemitterID.mark = 0;
  SwigClassPaymentRemitterID.destroy = (void (*)(void *)) free_FIX_PaymentRemitterID;
  SwigClassPaymentRemitterID.trackObjects = 0;
  
  SwigClassPriceType.klass = rb_define_class_under(mQuickfix, "PriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceType, (void *) &SwigClassPriceType);
  rb_define_alloc_func(SwigClassPriceType.klass, _wrap_PriceType_allocate);
  rb_define_method(SwigClassPriceType.klass, "initialize", VALUEFUNC(_wrap_new_PriceType), -1);
  SwigClassPriceType.mark = 0;
  SwigClassPriceType.destroy = (void (*)(void *)) free_FIX_PriceType;
  SwigClassPriceType.trackObjects = 0;
  
  SwigClassMarketReqID.klass = rb_define_class_under(mQuickfix, "MarketReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketReqID, (void *) &SwigClassMarketReqID);
  rb_define_alloc_func(SwigClassMarketReqID.klass, _wrap_MarketReqID_allocate);
  rb_define_method(SwigClassMarketReqID.klass, "initialize", VALUEFUNC(_wrap_new_MarketReqID), -1);
  SwigClassMarketReqID.mark = 0;
  SwigClassMarketReqID.destroy = (void (*)(void *)) free_FIX_MarketReqID;
  SwigClassMarketReqID.trackObjects = 0;
  
  SwigClassNoNestedInstrAttrib.klass = rb_define_class_under(mQuickfix, "NoNestedInstrAttrib", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNestedInstrAttrib, (void *) &SwigClassNoNestedInstrAttrib);
  rb_define_alloc_func(SwigClassNoNestedInstrAttrib.klass, _wrap_NoNestedInstrAttrib_allocate);
  rb_define_method(SwigClassNoNestedInstrAttrib.klass, "initialize", VALUEFUNC(_wrap_new_NoNestedInstrAttrib), -1);
  SwigClassNoNestedInstrAttrib.mark = 0;
  SwigClassNoNestedInstrAttrib.destroy = (void (*)(void *)) free_FIX_NoNestedInstrAttrib;
  SwigClassNoNestedInstrAttrib.trackObjects = 0;
  
  SwigClassSecuritySubType.klass = rb_define_class_under(mQuickfix, "SecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySubType, (void *) &SwigClassSecuritySubType);
  rb_define_alloc_func(SwigClassSecuritySubType.klass, _wrap_SecuritySubType_allocate);
  rb_define_method(SwigClassSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySubType), -1);
  SwigClassSecuritySubType.mark = 0;
  SwigClassSecuritySubType.destroy = (void (*)(void *)) free_FIX_SecuritySubType;
  SwigClassSecuritySubType.trackObjects = 0;
  
  SwigClassClOrdID.klass = rb_define_class_under(mQuickfix, "ClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClOrdID, (void *) &SwigClassClOrdID);
  rb_define_alloc_func(SwigClassClOrdID.klass, _wrap_ClOrdID_allocate);
  rb_define_method(SwigClassClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_ClOrdID), -1);
  SwigClassClOrdID.mark = 0;
  SwigClassClOrdID.destroy = (void (*)(void *)) free_FIX_ClOrdID;
  SwigClassClOrdID.trackObjects = 0;
  
  SwigClassMaturityDay.klass = rb_define_class_under(mQuickfix, "MaturityDay", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityDay, (void *) &SwigClassMaturityDay);
  rb_define_alloc_func(SwigClassMaturityDay.klass, _wrap_MaturityDay_allocate);
  rb_define_method(SwigClassMaturityDay.klass, "initialize", VALUEFUNC(_wrap_new_MaturityDay), -1);
  SwigClassMaturityDay.mark = 0;
  SwigClassMaturityDay.destroy = (void (*)(void *)) free_FIX_MaturityDay;
  SwigClassMaturityDay.trackObjects = 0;
  
  SwigClassUnderlyingSeniority.klass = rb_define_class_under(mQuickfix, "UnderlyingSeniority", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSeniority, (void *) &SwigClassUnderlyingSeniority);
  rb_define_alloc_func(SwigClassUnderlyingSeniority.klass, _wrap_UnderlyingSeniority_allocate);
  rb_define_method(SwigClassUnderlyingSeniority.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSeniority), -1);
  SwigClassUnderlyingSeniority.mark = 0;
  SwigClassUnderlyingSeniority.destroy = (void (*)(void *)) free_FIX_UnderlyingSeniority;
  SwigClassUnderlyingSeniority.trackObjects = 0;
  
  SwigClassMarketSegmentDesc.klass = rb_define_class_under(mQuickfix, "MarketSegmentDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketSegmentDesc, (void *) &SwigClassMarketSegmentDesc);
  rb_define_alloc_func(SwigClassMarketSegmentDesc.klass, _wrap_MarketSegmentDesc_allocate);
  rb_define_method(SwigClassMarketSegmentDesc.klass, "initialize", VALUEFUNC(_wrap_new_MarketSegmentDesc), -1);
  SwigClassMarketSegmentDesc.mark = 0;
  SwigClassMarketSegmentDesc.destroy = (void (*)(void *)) free_FIX_MarketSegmentDesc;
  SwigClassMarketSegmentDesc.trackObjects = 0;
  
  SwigClassNoMarketSegments.klass = rb_define_class_under(mQuickfix, "NoMarketSegments", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMarketSegments, (void *) &SwigClassNoMarketSegments);
  rb_define_alloc_func(SwigClassNoMarketSegments.klass, _wrap_NoMarketSegments_allocate);
  rb_define_method(SwigClassNoMarketSegments.klass, "initialize", VALUEFUNC(_wrap_new_NoMarketSegments), -1);
  SwigClassNoMarketSegments.mark = 0;
  SwigClassNoMarketSegments.destroy = (void (*)(void *)) free_FIX_NoMarketSegments;
  SwigClassNoMarketSegments.trackObjects = 0;
  
  SwigClassSettlObligMode.klass = rb_define_class_under(mQuickfix, "SettlObligMode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligMode, (void *) &SwigClassSettlObligMode);
  rb_define_alloc_func(SwigClassSettlObligMode.klass, _wrap_SettlObligMode_allocate);
  rb_define_method(SwigClassSettlObligMode.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligMode), -1);
  SwigClassSettlObligMode.mark = 0;
  SwigClassSettlObligMode.destroy = (void (*)(void *)) free_FIX_SettlObligMode;
  SwigClassSettlObligMode.trackObjects = 0;
  
  SwigClassSecurityUpdateAction.klass = rb_define_class_under(mQuickfix, "SecurityUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityUpdateAction, (void *) &SwigClassSecurityUpdateAction);
  rb_define_alloc_func(SwigClassSecurityUpdateAction.klass, _wrap_SecurityUpdateAction_allocate);
  rb_define_method(SwigClassSecurityUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_SecurityUpdateAction), -1);
  SwigClassSecurityUpdateAction.mark = 0;
  SwigClassSecurityUpdateAction.destroy = (void (*)(void *)) free_FIX_SecurityUpdateAction;
  SwigClassSecurityUpdateAction.trackObjects = 0;
  
  SwigClassNetworkRequestType.klass = rb_define_class_under(mQuickfix, "NetworkRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkRequestType, (void *) &SwigClassNetworkRequestType);
  rb_define_alloc_func(SwigClassNetworkRequestType.klass, _wrap_NetworkRequestType_allocate);
  rb_define_method(SwigClassNetworkRequestType.klass, "initialize", VALUEFUNC(_wrap_new_NetworkRequestType), -1);
  SwigClassNetworkRequestType.mark = 0;
  SwigClassNetworkRequestType.destroy = (void (*)(void *)) free_FIX_NetworkRequestType;
  SwigClassNetworkRequestType.trackObjects = 0;
  
  SwigClassLiquidityPctLow.klass = rb_define_class_under(mQuickfix, "LiquidityPctLow", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityPctLow, (void *) &SwigClassLiquidityPctLow);
  rb_define_alloc_func(SwigClassLiquidityPctLow.klass, _wrap_LiquidityPctLow_allocate);
  rb_define_method(SwigClassLiquidityPctLow.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityPctLow), -1);
  SwigClassLiquidityPctLow.mark = 0;
  SwigClassLiquidityPctLow.destroy = (void (*)(void *)) free_FIX_LiquidityPctLow;
  SwigClassLiquidityPctLow.trackObjects = 0;
  
  SwigClassPartyRole.klass = rb_define_class_under(mQuickfix, "PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyRole, (void *) &SwigClassPartyRole);
  rb_define_alloc_func(SwigClassPartyRole.klass, _wrap_PartyRole_allocate);
  rb_define_method(SwigClassPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_PartyRole), -1);
  SwigClassPartyRole.mark = 0;
  SwigClassPartyRole.destroy = (void (*)(void *)) free_FIX_PartyRole;
  SwigClassPartyRole.trackObjects = 0;
  
  SwigClassLegRatioQty.klass = rb_define_class_under(mQuickfix, "LegRatioQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRatioQty, (void *) &SwigClassLegRatioQty);
  rb_define_alloc_func(SwigClassLegRatioQty.klass, _wrap_LegRatioQty_allocate);
  rb_define_method(SwigClassLegRatioQty.klass, "initialize", VALUEFUNC(_wrap_new_LegRatioQty), -1);
  SwigClassLegRatioQty.mark = 0;
  SwigClassLegRatioQty.destroy = (void (*)(void *)) free_FIX_LegRatioQty;
  SwigClassLegRatioQty.trackObjects = 0;
  
  SwigClassSettlCurrFxRate.klass = rb_define_class_under(mQuickfix, "SettlCurrFxRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrFxRate, (void *) &SwigClassSettlCurrFxRate);
  rb_define_alloc_func(SwigClassSettlCurrFxRate.klass, _wrap_SettlCurrFxRate_allocate);
  rb_define_method(SwigClassSettlCurrFxRate.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrFxRate), -1);
  SwigClassSettlCurrFxRate.mark = 0;
  SwigClassSettlCurrFxRate.destroy = (void (*)(void *)) free_FIX_SettlCurrFxRate;
  SwigClassSettlCurrFxRate.trackObjects = 0;
  
  SwigClassLegContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "LegContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegContractMultiplierUnit, (void *) &SwigClassLegContractMultiplierUnit);
  rb_define_alloc_func(SwigClassLegContractMultiplierUnit.klass, _wrap_LegContractMultiplierUnit_allocate);
  rb_define_method(SwigClassLegContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_LegContractMultiplierUnit), -1);
  SwigClassLegContractMultiplierUnit.mark = 0;
  SwigClassLegContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_LegContractMultiplierUnit;
  SwigClassLegContractMultiplierUnit.trackObjects = 0;
  
  SwigClassSecureData.klass = rb_define_class_under(mQuickfix, "SecureData", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecureData, (void *) &SwigClassSecureData);
  rb_define_alloc_func(SwigClassSecureData.klass, _wrap_SecureData_allocate);
  rb_define_method(SwigClassSecureData.klass, "initialize", VALUEFUNC(_wrap_new_SecureData), -1);
  SwigClassSecureData.mark = 0;
  SwigClassSecureData.destroy = (void (*)(void *)) free_FIX_SecureData;
  SwigClassSecureData.trackObjects = 0;
  
  SwigClassSenderLocationID.klass = rb_define_class_under(mQuickfix, "SenderLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SenderLocationID, (void *) &SwigClassSenderLocationID);
  rb_define_alloc_func(SwigClassSenderLocationID.klass, _wrap_SenderLocationID_allocate);
  rb_define_method(SwigClassSenderLocationID.klass, "initialize", VALUEFUNC(_wrap_new_SenderLocationID), -1);
  SwigClassSenderLocationID.mark = 0;
  SwigClassSenderLocationID.destroy = (void (*)(void *)) free_FIX_SenderLocationID;
  SwigClassSenderLocationID.trackObjects = 0;
  
  SwigClassFirstPx.klass = rb_define_class_under(mQuickfix, "FirstPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FirstPx, (void *) &SwigClassFirstPx);
  rb_define_alloc_func(SwigClassFirstPx.klass, _wrap_FirstPx_allocate);
  rb_define_method(SwigClassFirstPx.klass, "initialize", VALUEFUNC(_wrap_new_FirstPx), -1);
  SwigClassFirstPx.mark = 0;
  SwigClassFirstPx.destroy = (void (*)(void *)) free_FIX_FirstPx;
  SwigClassFirstPx.trackObjects = 0;
  
  SwigClassEncodedLegIssuer.klass = rb_define_class_under(mQuickfix, "EncodedLegIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegIssuer, (void *) &SwigClassEncodedLegIssuer);
  rb_define_alloc_func(SwigClassEncodedLegIssuer.klass, _wrap_EncodedLegIssuer_allocate);
  rb_define_method(SwigClassEncodedLegIssuer.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegIssuer), -1);
  SwigClassEncodedLegIssuer.mark = 0;
  SwigClassEncodedLegIssuer.destroy = (void (*)(void *)) free_FIX_EncodedLegIssuer;
  SwigClassEncodedLegIssuer.trackObjects = 0;
  
  SwigClassAssignmentMethod.klass = rb_define_class_under(mQuickfix, "AssignmentMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AssignmentMethod, (void *) &SwigClassAssignmentMethod);
  rb_define_alloc_func(SwigClassAssignmentMethod.klass, _wrap_AssignmentMethod_allocate);
  rb_define_method(SwigClassAssignmentMethod.klass, "initialize", VALUEFUNC(_wrap_new_AssignmentMethod), -1);
  SwigClassAssignmentMethod.mark = 0;
  SwigClassAssignmentMethod.destroy = (void (*)(void *)) free_FIX_AssignmentMethod;
  SwigClassAssignmentMethod.trackObjects = 0;
  
  SwigClassRoutingID.klass = rb_define_class_under(mQuickfix, "RoutingID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoutingID, (void *) &SwigClassRoutingID);
  rb_define_alloc_func(SwigClassRoutingID.klass, _wrap_RoutingID_allocate);
  rb_define_method(SwigClassRoutingID.klass, "initialize", VALUEFUNC(_wrap_new_RoutingID), -1);
  SwigClassRoutingID.mark = 0;
  SwigClassRoutingID.destroy = (void (*)(void *)) free_FIX_RoutingID;
  SwigClassRoutingID.trackObjects = 0;
  
  SwigClassStrategyParameterType.klass = rb_define_class_under(mQuickfix, "StrategyParameterType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrategyParameterType, (void *) &SwigClassStrategyParameterType);
  rb_define_alloc_func(SwigClassStrategyParameterType.klass, _wrap_StrategyParameterType_allocate);
  rb_define_method(SwigClassStrategyParameterType.klass, "initialize", VALUEFUNC(_wrap_new_StrategyParameterType), -1);
  SwigClassStrategyParameterType.mark = 0;
  SwigClassStrategyParameterType.destroy = (void (*)(void *)) free_FIX_StrategyParameterType;
  SwigClassStrategyParameterType.trackObjects = 0;
  
  SwigClassEncryptMethod.klass = rb_define_class_under(mQuickfix, "EncryptMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptMethod, (void *) &SwigClassEncryptMethod);
  rb_define_alloc_func(SwigClassEncryptMethod.klass, _wrap_EncryptMethod_allocate);
  rb_define_method(SwigClassEncryptMethod.klass, "initialize", VALUEFUNC(_wrap_new_EncryptMethod), -1);
  SwigClassEncryptMethod.mark = 0;
  SwigClassEncryptMethod.destroy = (void (*)(void *)) free_FIX_EncryptMethod;
  SwigClassEncryptMethod.trackObjects = 0;
  
  SwigClassUnderlyingStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "UnderlyingStateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue, (void *) &SwigClassUnderlyingStateOrProvinceOfIssue);
  rb_define_alloc_func(SwigClassUnderlyingStateOrProvinceOfIssue.klass, _wrap_UnderlyingStateOrProvinceOfIssue_allocate);
  rb_define_method(SwigClassUnderlyingStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStateOrProvinceOfIssue), -1);
  SwigClassUnderlyingStateOrProvinceOfIssue.mark = 0;
  SwigClassUnderlyingStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_UnderlyingStateOrProvinceOfIssue;
  SwigClassUnderlyingStateOrProvinceOfIssue.trackObjects = 0;
  
  SwigClassApplNewSeqNum.klass = rb_define_class_under(mQuickfix, "ApplNewSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplNewSeqNum, (void *) &SwigClassApplNewSeqNum);
  rb_define_alloc_func(SwigClassApplNewSeqNum.klass, _wrap_ApplNewSeqNum_allocate);
  rb_define_method(SwigClassApplNewSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplNewSeqNum), -1);
  SwigClassApplNewSeqNum.mark = 0;
  SwigClassApplNewSeqNum.destroy = (void (*)(void *)) free_FIX_ApplNewSeqNum;
  SwigClassApplNewSeqNum.trackObjects = 0;
  
  SwigClassDerivativeEncodedSecurityDescLen.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen, (void *) &SwigClassDerivativeEncodedSecurityDescLen);
  rb_define_alloc_func(SwigClassDerivativeEncodedSecurityDescLen.klass, _wrap_DerivativeEncodedSecurityDescLen_allocate);
  rb_define_method(SwigClassDerivativeEncodedSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedSecurityDescLen), -1);
  SwigClassDerivativeEncodedSecurityDescLen.mark = 0;
  SwigClassDerivativeEncodedSecurityDescLen.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedSecurityDescLen;
  SwigClassDerivativeEncodedSecurityDescLen.trackObjects = 0;
  
  SwigClassTradingCurrency.klass = rb_define_class_under(mQuickfix, "TradingCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingCurrency, (void *) &SwigClassTradingCurrency);
  rb_define_alloc_func(SwigClassTradingCurrency.klass, _wrap_TradingCurrency_allocate);
  rb_define_method(SwigClassTradingCurrency.klass, "initialize", VALUEFUNC(_wrap_new_TradingCurrency), -1);
  SwigClassTradingCurrency.mark = 0;
  SwigClassTradingCurrency.destroy = (void (*)(void *)) free_FIX_TradingCurrency;
  SwigClassTradingCurrency.trackObjects = 0;
  
  SwigClassSecondaryHighLimitPrice.klass = rb_define_class_under(mQuickfix, "SecondaryHighLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryHighLimitPrice, (void *) &SwigClassSecondaryHighLimitPrice);
  rb_define_alloc_func(SwigClassSecondaryHighLimitPrice.klass, _wrap_SecondaryHighLimitPrice_allocate);
  rb_define_method(SwigClassSecondaryHighLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryHighLimitPrice), -1);
  SwigClassSecondaryHighLimitPrice.mark = 0;
  SwigClassSecondaryHighLimitPrice.destroy = (void (*)(void *)) free_FIX_SecondaryHighLimitPrice;
  SwigClassSecondaryHighLimitPrice.trackObjects = 0;
  
  SwigClassOrderAvgPx.klass = rb_define_class_under(mQuickfix, "OrderAvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderAvgPx, (void *) &SwigClassOrderAvgPx);
  rb_define_alloc_func(SwigClassOrderAvgPx.klass, _wrap_OrderAvgPx_allocate);
  rb_define_method(SwigClassOrderAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_OrderAvgPx), -1);
  SwigClassOrderAvgPx.mark = 0;
  SwigClassOrderAvgPx.destroy = (void (*)(void *)) free_FIX_OrderAvgPx;
  SwigClassOrderAvgPx.trackObjects = 0;
  
  SwigClassPosAmtType.klass = rb_define_class_under(mQuickfix, "PosAmtType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosAmtType, (void *) &SwigClassPosAmtType);
  rb_define_alloc_func(SwigClassPosAmtType.klass, _wrap_PosAmtType_allocate);
  rb_define_method(SwigClassPosAmtType.klass, "initialize", VALUEFUNC(_wrap_new_PosAmtType), -1);
  SwigClassPosAmtType.mark = 0;
  SwigClassPosAmtType.destroy = (void (*)(void *)) free_FIX_PosAmtType;
  SwigClassPosAmtType.trackObjects = 0;
  
  SwigClassResetSeqNumFlag.klass = rb_define_class_under(mQuickfix, "ResetSeqNumFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ResetSeqNumFlag, (void *) &SwigClassResetSeqNumFlag);
  rb_define_alloc_func(SwigClassResetSeqNumFlag.klass, _wrap_ResetSeqNumFlag_allocate);
  rb_define_method(SwigClassResetSeqNumFlag.klass, "initialize", VALUEFUNC(_wrap_new_ResetSeqNumFlag), -1);
  SwigClassResetSeqNumFlag.mark = 0;
  SwigClassResetSeqNumFlag.destroy = (void (*)(void *)) free_FIX_ResetSeqNumFlag;
  SwigClassResetSeqNumFlag.trackObjects = 0;
  
  SwigClassNoHops.klass = rb_define_class_under(mQuickfix, "NoHops", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoHops, (void *) &SwigClassNoHops);
  rb_define_alloc_func(SwigClassNoHops.klass, _wrap_NoHops_allocate);
  rb_define_method(SwigClassNoHops.klass, "initialize", VALUEFUNC(_wrap_new_NoHops), -1);
  SwigClassNoHops.mark = 0;
  SwigClassNoHops.destroy = (void (*)(void *)) free_FIX_NoHops;
  SwigClassNoHops.trackObjects = 0;
  
  SwigClassCollInquiryResult.klass = rb_define_class_under(mQuickfix, "CollInquiryResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryResult, (void *) &SwigClassCollInquiryResult);
  rb_define_alloc_func(SwigClassCollInquiryResult.klass, _wrap_CollInquiryResult_allocate);
  rb_define_method(SwigClassCollInquiryResult.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryResult), -1);
  SwigClassCollInquiryResult.mark = 0;
  SwigClassCollInquiryResult.destroy = (void (*)(void *)) free_FIX_CollInquiryResult;
  SwigClassCollInquiryResult.trackObjects = 0;
  
  SwigClassStartDate.klass = rb_define_class_under(mQuickfix, "StartDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartDate, (void *) &SwigClassStartDate);
  rb_define_alloc_func(SwigClassStartDate.klass, _wrap_StartDate_allocate);
  rb_define_method(SwigClassStartDate.klass, "initialize", VALUEFUNC(_wrap_new_StartDate), -1);
  SwigClassStartDate.mark = 0;
  SwigClassStartDate.destroy = (void (*)(void *)) free_FIX_StartDate;
  SwigClassStartDate.trackObjects = 0;
  
  SwigClassCollAsgnRespType.klass = rb_define_class_under(mQuickfix, "CollAsgnRespType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnRespType, (void *) &SwigClassCollAsgnRespType);
  rb_define_alloc_func(SwigClassCollAsgnRespType.klass, _wrap_CollAsgnRespType_allocate);
  rb_define_method(SwigClassCollAsgnRespType.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnRespType), -1);
  SwigClassCollAsgnRespType.mark = 0;
  SwigClassCollAsgnRespType.destroy = (void (*)(void *)) free_FIX_CollAsgnRespType;
  SwigClassCollAsgnRespType.trackObjects = 0;
  
  SwigClassOrderBookingQty.klass = rb_define_class_under(mQuickfix, "OrderBookingQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderBookingQty, (void *) &SwigClassOrderBookingQty);
  rb_define_alloc_func(SwigClassOrderBookingQty.klass, _wrap_OrderBookingQty_allocate);
  rb_define_method(SwigClassOrderBookingQty.klass, "initialize", VALUEFUNC(_wrap_new_OrderBookingQty), -1);
  SwigClassOrderBookingQty.mark = 0;
  SwigClassOrderBookingQty.destroy = (void (*)(void *)) free_FIX_OrderBookingQty;
  SwigClassOrderBookingQty.trackObjects = 0;
  
  SwigClassNoQuoteQualifiers.klass = rb_define_class_under(mQuickfix, "NoQuoteQualifiers", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoQuoteQualifiers, (void *) &SwigClassNoQuoteQualifiers);
  rb_define_alloc_func(SwigClassNoQuoteQualifiers.klass, _wrap_NoQuoteQualifiers_allocate);
  rb_define_method(SwigClassNoQuoteQualifiers.klass, "initialize", VALUEFUNC(_wrap_new_NoQuoteQualifiers), -1);
  SwigClassNoQuoteQualifiers.mark = 0;
  SwigClassNoQuoteQualifiers.destroy = (void (*)(void *)) free_FIX_NoQuoteQualifiers;
  SwigClassNoQuoteQualifiers.trackObjects = 0;
  
  SwigClassUnsolicitedIndicator.klass = rb_define_class_under(mQuickfix, "UnsolicitedIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnsolicitedIndicator, (void *) &SwigClassUnsolicitedIndicator);
  rb_define_alloc_func(SwigClassUnsolicitedIndicator.klass, _wrap_UnsolicitedIndicator_allocate);
  rb_define_method(SwigClassUnsolicitedIndicator.klass, "initialize", VALUEFUNC(_wrap_new_UnsolicitedIndicator), -1);
  SwigClassUnsolicitedIndicator.mark = 0;
  SwigClassUnsolicitedIndicator.destroy = (void (*)(void *)) free_FIX_UnsolicitedIndicator;
  SwigClassUnsolicitedIndicator.trackObjects = 0;
  
  SwigClassRefCstmApplVerID.klass = rb_define_class_under(mQuickfix, "RefCstmApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefCstmApplVerID, (void *) &SwigClassRefCstmApplVerID);
  rb_define_alloc_func(SwigClassRefCstmApplVerID.klass, _wrap_RefCstmApplVerID_allocate);
  rb_define_method(SwigClassRefCstmApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_RefCstmApplVerID), -1);
  SwigClassRefCstmApplVerID.mark = 0;
  SwigClassRefCstmApplVerID.destroy = (void (*)(void *)) free_FIX_RefCstmApplVerID;
  SwigClassRefCstmApplVerID.trackObjects = 0;
  
  SwigClassSideExecID.klass = rb_define_class_under(mQuickfix, "SideExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideExecID, (void *) &SwigClassSideExecID);
  rb_define_alloc_func(SwigClassSideExecID.klass, _wrap_SideExecID_allocate);
  rb_define_method(SwigClassSideExecID.klass, "initialize", VALUEFUNC(_wrap_new_SideExecID), -1);
  SwigClassSideExecID.mark = 0;
  SwigClassSideExecID.destroy = (void (*)(void *)) free_FIX_SideExecID;
  SwigClassSideExecID.trackObjects = 0;
  
  SwigClassRejectText.klass = rb_define_class_under(mQuickfix, "RejectText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RejectText, (void *) &SwigClassRejectText);
  rb_define_alloc_func(SwigClassRejectText.klass, _wrap_RejectText_allocate);
  rb_define_method(SwigClassRejectText.klass, "initialize", VALUEFUNC(_wrap_new_RejectText), -1);
  SwigClassRejectText.mark = 0;
  SwigClassRejectText.destroy = (void (*)(void *)) free_FIX_RejectText;
  SwigClassRejectText.trackObjects = 0;
  
  SwigClassExchangeSpecialInstructions.klass = rb_define_class_under(mQuickfix, "ExchangeSpecialInstructions", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExchangeSpecialInstructions, (void *) &SwigClassExchangeSpecialInstructions);
  rb_define_alloc_func(SwigClassExchangeSpecialInstructions.klass, _wrap_ExchangeSpecialInstructions_allocate);
  rb_define_method(SwigClassExchangeSpecialInstructions.klass, "initialize", VALUEFUNC(_wrap_new_ExchangeSpecialInstructions), -1);
  SwigClassExchangeSpecialInstructions.mark = 0;
  SwigClassExchangeSpecialInstructions.destroy = (void (*)(void *)) free_FIX_ExchangeSpecialInstructions;
  SwigClassExchangeSpecialInstructions.trackObjects = 0;
  
  SwigClassTradeID.klass = rb_define_class_under(mQuickfix, "TradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeID, (void *) &SwigClassTradeID);
  rb_define_alloc_func(SwigClassTradeID.klass, _wrap_TradeID_allocate);
  rb_define_method(SwigClassTradeID.klass, "initialize", VALUEFUNC(_wrap_new_TradeID), -1);
  SwigClassTradeID.mark = 0;
  SwigClassTradeID.destroy = (void (*)(void *)) free_FIX_TradeID;
  SwigClassTradeID.trackObjects = 0;
  
  SwigClassRndPx.klass = rb_define_class_under(mQuickfix, "RndPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RndPx, (void *) &SwigClassRndPx);
  rb_define_alloc_func(SwigClassRndPx.klass, _wrap_RndPx_allocate);
  rb_define_method(SwigClassRndPx.klass, "initialize", VALUEFUNC(_wrap_new_RndPx), -1);
  SwigClassRndPx.mark = 0;
  SwigClassRndPx.destroy = (void (*)(void *)) free_FIX_RndPx;
  SwigClassRndPx.trackObjects = 0;
  
  SwigClassQuoteEntryRejectReason.klass = rb_define_class_under(mQuickfix, "QuoteEntryRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteEntryRejectReason, (void *) &SwigClassQuoteEntryRejectReason);
  rb_define_alloc_func(SwigClassQuoteEntryRejectReason.klass, _wrap_QuoteEntryRejectReason_allocate);
  rb_define_method(SwigClassQuoteEntryRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_QuoteEntryRejectReason), -1);
  SwigClassQuoteEntryRejectReason.mark = 0;
  SwigClassQuoteEntryRejectReason.destroy = (void (*)(void *)) free_FIX_QuoteEntryRejectReason;
  SwigClassQuoteEntryRejectReason.trackObjects = 0;
  
  SwigClassOrderCapacity.klass = rb_define_class_under(mQuickfix, "OrderCapacity", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderCapacity, (void *) &SwigClassOrderCapacity);
  rb_define_alloc_func(SwigClassOrderCapacity.klass, _wrap_OrderCapacity_allocate);
  rb_define_method(SwigClassOrderCapacity.klass, "initialize", VALUEFUNC(_wrap_new_OrderCapacity), -1);
  SwigClassOrderCapacity.mark = 0;
  SwigClassOrderCapacity.destroy = (void (*)(void *)) free_FIX_OrderCapacity;
  SwigClassOrderCapacity.trackObjects = 0;
  
  SwigClassSideLastQty.klass = rb_define_class_under(mQuickfix, "SideLastQty", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideLastQty, (void *) &SwigClassSideLastQty);
  rb_define_alloc_func(SwigClassSideLastQty.klass, _wrap_SideLastQty_allocate);
  rb_define_method(SwigClassSideLastQty.klass, "initialize", VALUEFUNC(_wrap_new_SideLastQty), -1);
  SwigClassSideLastQty.mark = 0;
  SwigClassSideLastQty.destroy = (void (*)(void *)) free_FIX_SideLastQty;
  SwigClassSideLastQty.trackObjects = 0;
  
  SwigClassDerivativeUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "DerivativeUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeUnitOfMeasure, (void *) &SwigClassDerivativeUnitOfMeasure);
  rb_define_alloc_func(SwigClassDerivativeUnitOfMeasure.klass, _wrap_DerivativeUnitOfMeasure_allocate);
  rb_define_method(SwigClassDerivativeUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeUnitOfMeasure), -1);
  SwigClassDerivativeUnitOfMeasure.mark = 0;
  SwigClassDerivativeUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_DerivativeUnitOfMeasure;
  SwigClassDerivativeUnitOfMeasure.trackObjects = 0;
  
  SwigClassNoLegAllocs.klass = rb_define_class_under(mQuickfix, "NoLegAllocs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegAllocs, (void *) &SwigClassNoLegAllocs);
  rb_define_alloc_func(SwigClassNoLegAllocs.klass, _wrap_NoLegAllocs_allocate);
  rb_define_method(SwigClassNoLegAllocs.klass, "initialize", VALUEFUNC(_wrap_new_NoLegAllocs), -1);
  SwigClassNoLegAllocs.mark = 0;
  SwigClassNoLegAllocs.destroy = (void (*)(void *)) free_FIX_NoLegAllocs;
  SwigClassNoLegAllocs.trackObjects = 0;
  
  SwigClassQuoteAckStatus.klass = rb_define_class_under(mQuickfix, "QuoteAckStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteAckStatus, (void *) &SwigClassQuoteAckStatus);
  rb_define_alloc_func(SwigClassQuoteAckStatus.klass, _wrap_QuoteAckStatus_allocate);
  rb_define_method(SwigClassQuoteAckStatus.klass, "initialize", VALUEFUNC(_wrap_new_QuoteAckStatus), -1);
  SwigClassQuoteAckStatus.mark = 0;
  SwigClassQuoteAckStatus.destroy = (void (*)(void *)) free_FIX_QuoteAckStatus;
  SwigClassQuoteAckStatus.trackObjects = 0;
  
  SwigClassSecondaryFirmTradeID.klass = rb_define_class_under(mQuickfix, "SecondaryFirmTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryFirmTradeID, (void *) &SwigClassSecondaryFirmTradeID);
  rb_define_alloc_func(SwigClassSecondaryFirmTradeID.klass, _wrap_SecondaryFirmTradeID_allocate);
  rb_define_method(SwigClassSecondaryFirmTradeID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryFirmTradeID), -1);
  SwigClassSecondaryFirmTradeID.mark = 0;
  SwigClassSecondaryFirmTradeID.destroy = (void (*)(void *)) free_FIX_SecondaryFirmTradeID;
  SwigClassSecondaryFirmTradeID.trackObjects = 0;
  
  SwigClassUserRequestType.klass = rb_define_class_under(mQuickfix, "UserRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserRequestType, (void *) &SwigClassUserRequestType);
  rb_define_alloc_func(SwigClassUserRequestType.klass, _wrap_UserRequestType_allocate);
  rb_define_method(SwigClassUserRequestType.klass, "initialize", VALUEFUNC(_wrap_new_UserRequestType), -1);
  SwigClassUserRequestType.mark = 0;
  SwigClassUserRequestType.destroy = (void (*)(void *)) free_FIX_UserRequestType;
  SwigClassUserRequestType.trackObjects = 0;
  
  SwigClassSecondaryTrdType.klass = rb_define_class_under(mQuickfix, "SecondaryTrdType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTrdType, (void *) &SwigClassSecondaryTrdType);
  rb_define_alloc_func(SwigClassSecondaryTrdType.klass, _wrap_SecondaryTrdType_allocate);
  rb_define_method(SwigClassSecondaryTrdType.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTrdType), -1);
  SwigClassSecondaryTrdType.mark = 0;
  SwigClassSecondaryTrdType.destroy = (void (*)(void *)) free_FIX_SecondaryTrdType;
  SwigClassSecondaryTrdType.trackObjects = 0;
  
  SwigClassTradeReportTransType.klass = rb_define_class_under(mQuickfix, "TradeReportTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportTransType, (void *) &SwigClassTradeReportTransType);
  rb_define_alloc_func(SwigClassTradeReportTransType.klass, _wrap_TradeReportTransType_allocate);
  rb_define_method(SwigClassTradeReportTransType.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportTransType), -1);
  SwigClassTradeReportTransType.mark = 0;
  SwigClassTradeReportTransType.destroy = (void (*)(void *)) free_FIX_TradeReportTransType;
  SwigClassTradeReportTransType.trackObjects = 0;
  
  SwigClassAdvSide.klass = rb_define_class_under(mQuickfix, "AdvSide", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvSide, (void *) &SwigClassAdvSide);
  rb_define_alloc_func(SwigClassAdvSide.klass, _wrap_AdvSide_allocate);
  rb_define_method(SwigClassAdvSide.klass, "initialize", VALUEFUNC(_wrap_new_AdvSide), -1);
  SwigClassAdvSide.mark = 0;
  SwigClassAdvSide.destroy = (void (*)(void *)) free_FIX_AdvSide;
  SwigClassAdvSide.trackObjects = 0;
  
  SwigClassDerivativeSecuritySubType.klass = rb_define_class_under(mQuickfix, "DerivativeSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecuritySubType, (void *) &SwigClassDerivativeSecuritySubType);
  rb_define_alloc_func(SwigClassDerivativeSecuritySubType.klass, _wrap_DerivativeSecuritySubType_allocate);
  rb_define_method(SwigClassDerivativeSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecuritySubType), -1);
  SwigClassDerivativeSecuritySubType.mark = 0;
  SwigClassDerivativeSecuritySubType.destroy = (void (*)(void *)) free_FIX_DerivativeSecuritySubType;
  SwigClassDerivativeSecuritySubType.trackObjects = 0;
  
  SwigClassTriggerTradingSessionSubID.klass = rb_define_class_under(mQuickfix, "TriggerTradingSessionSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerTradingSessionSubID, (void *) &SwigClassTriggerTradingSessionSubID);
  rb_define_alloc_func(SwigClassTriggerTradingSessionSubID.klass, _wrap_TriggerTradingSessionSubID_allocate);
  rb_define_method(SwigClassTriggerTradingSessionSubID.klass, "initialize", VALUEFUNC(_wrap_new_TriggerTradingSessionSubID), -1);
  SwigClassTriggerTradingSessionSubID.mark = 0;
  SwigClassTriggerTradingSessionSubID.destroy = (void (*)(void *)) free_FIX_TriggerTradingSessionSubID;
  SwigClassTriggerTradingSessionSubID.trackObjects = 0;
  
  SwigClassTradeLinkID.klass = rb_define_class_under(mQuickfix, "TradeLinkID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeLinkID, (void *) &SwigClassTradeLinkID);
  rb_define_alloc_func(SwigClassTradeLinkID.klass, _wrap_TradeLinkID_allocate);
  rb_define_method(SwigClassTradeLinkID.klass, "initialize", VALUEFUNC(_wrap_new_TradeLinkID), -1);
  SwigClassTradeLinkID.mark = 0;
  SwigClassTradeLinkID.destroy = (void (*)(void *)) free_FIX_TradeLinkID;
  SwigClassTradeLinkID.trackObjects = 0;
  
  SwigClassLegBenchmarkPrice.klass = rb_define_class_under(mQuickfix, "LegBenchmarkPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkPrice, (void *) &SwigClassLegBenchmarkPrice);
  rb_define_alloc_func(SwigClassLegBenchmarkPrice.klass, _wrap_LegBenchmarkPrice_allocate);
  rb_define_method(SwigClassLegBenchmarkPrice.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkPrice), -1);
  SwigClassLegBenchmarkPrice.mark = 0;
  SwigClassLegBenchmarkPrice.destroy = (void (*)(void *)) free_FIX_LegBenchmarkPrice;
  SwigClassLegBenchmarkPrice.trackObjects = 0;
  
  SwigClassHopRefID.klass = rb_define_class_under(mQuickfix, "HopRefID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HopRefID, (void *) &SwigClassHopRefID);
  rb_define_alloc_func(SwigClassHopRefID.klass, _wrap_HopRefID_allocate);
  rb_define_method(SwigClassHopRefID.klass, "initialize", VALUEFUNC(_wrap_new_HopRefID), -1);
  SwigClassHopRefID.mark = 0;
  SwigClassHopRefID.destroy = (void (*)(void *)) free_FIX_HopRefID;
  SwigClassHopRefID.trackObjects = 0;
  
  SwigClassDesignation.klass = rb_define_class_under(mQuickfix, "Designation", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Designation, (void *) &SwigClassDesignation);
  rb_define_alloc_func(SwigClassDesignation.klass, _wrap_Designation_allocate);
  rb_define_method(SwigClassDesignation.klass, "initialize", VALUEFUNC(_wrap_new_Designation), -1);
  SwigClassDesignation.mark = 0;
  SwigClassDesignation.destroy = (void (*)(void *)) free_FIX_Designation;
  SwigClassDesignation.trackObjects = 0;
  
  SwigClassTradeRequestID.klass = rb_define_class_under(mQuickfix, "TradeRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestID, (void *) &SwigClassTradeRequestID);
  rb_define_alloc_func(SwigClassTradeRequestID.klass, _wrap_TradeRequestID_allocate);
  rb_define_method(SwigClassTradeRequestID.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestID), -1);
  SwigClassTradeRequestID.mark = 0;
  SwigClassTradeRequestID.destroy = (void (*)(void *)) free_FIX_TradeRequestID;
  SwigClassTradeRequestID.trackObjects = 0;
  
  SwigClassLegFlowScheduleType.klass = rb_define_class_under(mQuickfix, "LegFlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegFlowScheduleType, (void *) &SwigClassLegFlowScheduleType);
  rb_define_alloc_func(SwigClassLegFlowScheduleType.klass, _wrap_LegFlowScheduleType_allocate);
  rb_define_method(SwigClassLegFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_LegFlowScheduleType), -1);
  SwigClassLegFlowScheduleType.mark = 0;
  SwigClassLegFlowScheduleType.destroy = (void (*)(void *)) free_FIX_LegFlowScheduleType;
  SwigClassLegFlowScheduleType.trackObjects = 0;
  
  SwigClassLegPriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "LegPriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPriceUnitOfMeasure, (void *) &SwigClassLegPriceUnitOfMeasure);
  rb_define_alloc_func(SwigClassLegPriceUnitOfMeasure.klass, _wrap_LegPriceUnitOfMeasure_allocate);
  rb_define_method(SwigClassLegPriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_LegPriceUnitOfMeasure), -1);
  SwigClassLegPriceUnitOfMeasure.mark = 0;
  SwigClassLegPriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_LegPriceUnitOfMeasure;
  SwigClassLegPriceUnitOfMeasure.trackObjects = 0;
  
  SwigClassNested4PartyIDSource.klass = rb_define_class_under(mQuickfix, "Nested4PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartyIDSource, (void *) &SwigClassNested4PartyIDSource);
  rb_define_alloc_func(SwigClassNested4PartyIDSource.klass, _wrap_Nested4PartyIDSource_allocate);
  rb_define_method(SwigClassNested4PartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartyIDSource), -1);
  SwigClassNested4PartyIDSource.mark = 0;
  SwigClassNested4PartyIDSource.destroy = (void (*)(void *)) free_FIX_Nested4PartyIDSource;
  SwigClassNested4PartyIDSource.trackObjects = 0;
  
  SwigClassCoveredOrUncovered.klass = rb_define_class_under(mQuickfix, "CoveredOrUncovered", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CoveredOrUncovered, (void *) &SwigClassCoveredOrUncovered);
  rb_define_alloc_func(SwigClassCoveredOrUncovered.klass, _wrap_CoveredOrUncovered_allocate);
  rb_define_method(SwigClassCoveredOrUncovered.klass, "initialize", VALUEFUNC(_wrap_new_CoveredOrUncovered), -1);
  SwigClassCoveredOrUncovered.mark = 0;
  SwigClassCoveredOrUncovered.destroy = (void (*)(void *)) free_FIX_CoveredOrUncovered;
  SwigClassCoveredOrUncovered.trackObjects = 0;
  
  SwigClassAcctIDSource.klass = rb_define_class_under(mQuickfix, "AcctIDSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AcctIDSource, (void *) &SwigClassAcctIDSource);
  rb_define_alloc_func(SwigClassAcctIDSource.klass, _wrap_AcctIDSource_allocate);
  rb_define_method(SwigClassAcctIDSource.klass, "initialize", VALUEFUNC(_wrap_new_AcctIDSource), -1);
  SwigClassAcctIDSource.mark = 0;
  SwigClassAcctIDSource.destroy = (void (*)(void *)) free_FIX_AcctIDSource;
  SwigClassAcctIDSource.trackObjects = 0;
  
  SwigClassMktOfferPx.klass = rb_define_class_under(mQuickfix, "MktOfferPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MktOfferPx, (void *) &SwigClassMktOfferPx);
  rb_define_alloc_func(SwigClassMktOfferPx.klass, _wrap_MktOfferPx_allocate);
  rb_define_method(SwigClassMktOfferPx.klass, "initialize", VALUEFUNC(_wrap_new_MktOfferPx), -1);
  SwigClassMktOfferPx.mark = 0;
  SwigClassMktOfferPx.destroy = (void (*)(void *)) free_FIX_MktOfferPx;
  SwigClassMktOfferPx.trackObjects = 0;
  
  SwigClassNoCapacities.klass = rb_define_class_under(mQuickfix, "NoCapacities", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoCapacities, (void *) &SwigClassNoCapacities);
  rb_define_alloc_func(SwigClassNoCapacities.klass, _wrap_NoCapacities_allocate);
  rb_define_method(SwigClassNoCapacities.klass, "initialize", VALUEFUNC(_wrap_new_NoCapacities), -1);
  SwigClassNoCapacities.mark = 0;
  SwigClassNoCapacities.destroy = (void (*)(void *)) free_FIX_NoCapacities;
  SwigClassNoCapacities.trackObjects = 0;
  
  SwigClassTradeRequestType.klass = rb_define_class_under(mQuickfix, "TradeRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestType, (void *) &SwigClassTradeRequestType);
  rb_define_alloc_func(SwigClassTradeRequestType.klass, _wrap_TradeRequestType_allocate);
  rb_define_method(SwigClassTradeRequestType.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestType), -1);
  SwigClassTradeRequestType.mark = 0;
  SwigClassTradeRequestType.destroy = (void (*)(void *)) free_FIX_TradeRequestType;
  SwigClassTradeRequestType.trackObjects = 0;
  
  SwigClassNoNestedPartyIDs.klass = rb_define_class_under(mQuickfix, "NoNestedPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNestedPartyIDs, (void *) &SwigClassNoNestedPartyIDs);
  rb_define_alloc_func(SwigClassNoNestedPartyIDs.klass, _wrap_NoNestedPartyIDs_allocate);
  rb_define_method(SwigClassNoNestedPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNestedPartyIDs), -1);
  SwigClassNoNestedPartyIDs.mark = 0;
  SwigClassNoNestedPartyIDs.destroy = (void (*)(void *)) free_FIX_NoNestedPartyIDs;
  SwigClassNoNestedPartyIDs.trackObjects = 0;
  
  SwigClassTradSesStatus.klass = rb_define_class_under(mQuickfix, "TradSesStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesStatus, (void *) &SwigClassTradSesStatus);
  rb_define_alloc_func(SwigClassTradSesStatus.klass, _wrap_TradSesStatus_allocate);
  rb_define_method(SwigClassTradSesStatus.klass, "initialize", VALUEFUNC(_wrap_new_TradSesStatus), -1);
  SwigClassTradSesStatus.mark = 0;
  SwigClassTradSesStatus.destroy = (void (*)(void *)) free_FIX_TradSesStatus;
  SwigClassTradSesStatus.trackObjects = 0;
  
  SwigClassUnderlyingNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "UnderlyingNotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding, (void *) &SwigClassUnderlyingNotionalPercentageOutstanding);
  rb_define_alloc_func(SwigClassUnderlyingNotionalPercentageOutstanding.klass, _wrap_UnderlyingNotionalPercentageOutstanding_allocate);
  rb_define_method(SwigClassUnderlyingNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingNotionalPercentageOutstanding), -1);
  SwigClassUnderlyingNotionalPercentageOutstanding.mark = 0;
  SwigClassUnderlyingNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_UnderlyingNotionalPercentageOutstanding;
  SwigClassUnderlyingNotionalPercentageOutstanding.trackObjects = 0;
  
  SwigClassApplLastSeqNum.klass = rb_define_class_under(mQuickfix, "ApplLastSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplLastSeqNum, (void *) &SwigClassApplLastSeqNum);
  rb_define_alloc_func(SwigClassApplLastSeqNum.klass, _wrap_ApplLastSeqNum_allocate);
  rb_define_method(SwigClassApplLastSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplLastSeqNum), -1);
  SwigClassApplLastSeqNum.mark = 0;
  SwigClassApplLastSeqNum.destroy = (void (*)(void *)) free_FIX_ApplLastSeqNum;
  SwigClassApplLastSeqNum.trackObjects = 0;
  
  SwigClassPegPriceType.klass = rb_define_class_under(mQuickfix, "PegPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegPriceType, (void *) &SwigClassPegPriceType);
  rb_define_alloc_func(SwigClassPegPriceType.klass, _wrap_PegPriceType_allocate);
  rb_define_method(SwigClassPegPriceType.klass, "initialize", VALUEFUNC(_wrap_new_PegPriceType), -1);
  SwigClassPegPriceType.mark = 0;
  SwigClassPegPriceType.destroy = (void (*)(void *)) free_FIX_PegPriceType;
  SwigClassPegPriceType.trackObjects = 0;
  
  SwigClassStrategyParameterName.klass = rb_define_class_under(mQuickfix, "StrategyParameterName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrategyParameterName, (void *) &SwigClassStrategyParameterName);
  rb_define_alloc_func(SwigClassStrategyParameterName.klass, _wrap_StrategyParameterName_allocate);
  rb_define_method(SwigClassStrategyParameterName.klass, "initialize", VALUEFUNC(_wrap_new_StrategyParameterName), -1);
  SwigClassStrategyParameterName.mark = 0;
  SwigClassStrategyParameterName.destroy = (void (*)(void *)) free_FIX_StrategyParameterName;
  SwigClassStrategyParameterName.trackObjects = 0;
  
  SwigClassStreamAsgnRejReason.klass = rb_define_class_under(mQuickfix, "StreamAsgnRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnRejReason, (void *) &SwigClassStreamAsgnRejReason);
  rb_define_alloc_func(SwigClassStreamAsgnRejReason.klass, _wrap_StreamAsgnRejReason_allocate);
  rb_define_method(SwigClassStreamAsgnRejReason.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnRejReason), -1);
  SwigClassStreamAsgnRejReason.mark = 0;
  SwigClassStreamAsgnRejReason.destroy = (void (*)(void *)) free_FIX_StreamAsgnRejReason;
  SwigClassStreamAsgnRejReason.trackObjects = 0;
  
  SwigClassMatchIncrement.klass = rb_define_class_under(mQuickfix, "MatchIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchIncrement, (void *) &SwigClassMatchIncrement);
  rb_define_alloc_func(SwigClassMatchIncrement.klass, _wrap_MatchIncrement_allocate);
  rb_define_method(SwigClassMatchIncrement.klass, "initialize", VALUEFUNC(_wrap_new_MatchIncrement), -1);
  SwigClassMatchIncrement.mark = 0;
  SwigClassMatchIncrement.destroy = (void (*)(void *)) free_FIX_MatchIncrement;
  SwigClassMatchIncrement.trackObjects = 0;
  
  SwigClassNested3PartyRole.klass = rb_define_class_under(mQuickfix, "Nested3PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartyRole, (void *) &SwigClassNested3PartyRole);
  rb_define_alloc_func(SwigClassNested3PartyRole.klass, _wrap_Nested3PartyRole_allocate);
  rb_define_method(SwigClassNested3PartyRole.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartyRole), -1);
  SwigClassNested3PartyRole.mark = 0;
  SwigClassNested3PartyRole.destroy = (void (*)(void *)) free_FIX_Nested3PartyRole;
  SwigClassNested3PartyRole.trackObjects = 0;
  
  SwigClassUnderlyingPx.klass = rb_define_class_under(mQuickfix, "UnderlyingPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPx, (void *) &SwigClassUnderlyingPx);
  rb_define_alloc_func(SwigClassUnderlyingPx.klass, _wrap_UnderlyingPx_allocate);
  rb_define_method(SwigClassUnderlyingPx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPx), -1);
  SwigClassUnderlyingPx.mark = 0;
  SwigClassUnderlyingPx.destroy = (void (*)(void *)) free_FIX_UnderlyingPx;
  SwigClassUnderlyingPx.trackObjects = 0;
  
  SwigClassPriceImprovement.klass = rb_define_class_under(mQuickfix, "PriceImprovement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceImprovement, (void *) &SwigClassPriceImprovement);
  rb_define_alloc_func(SwigClassPriceImprovement.klass, _wrap_PriceImprovement_allocate);
  rb_define_method(SwigClassPriceImprovement.klass, "initialize", VALUEFUNC(_wrap_new_PriceImprovement), -1);
  SwigClassPriceImprovement.mark = 0;
  SwigClassPriceImprovement.destroy = (void (*)(void *)) free_FIX_PriceImprovement;
  SwigClassPriceImprovement.trackObjects = 0;
  
  SwigClassValuationMethod.klass = rb_define_class_under(mQuickfix, "ValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ValuationMethod, (void *) &SwigClassValuationMethod);
  rb_define_alloc_func(SwigClassValuationMethod.klass, _wrap_ValuationMethod_allocate);
  rb_define_method(SwigClassValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_ValuationMethod), -1);
  SwigClassValuationMethod.mark = 0;
  SwigClassValuationMethod.destroy = (void (*)(void *)) free_FIX_ValuationMethod;
  SwigClassValuationMethod.trackObjects = 0;
  
  SwigClassDerivativeSecurityID.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityID, (void *) &SwigClassDerivativeSecurityID);
  rb_define_alloc_func(SwigClassDerivativeSecurityID.klass, _wrap_DerivativeSecurityID_allocate);
  rb_define_method(SwigClassDerivativeSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityID), -1);
  SwigClassDerivativeSecurityID.mark = 0;
  SwigClassDerivativeSecurityID.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityID;
  SwigClassDerivativeSecurityID.trackObjects = 0;
  
  SwigClassNoExpiration.klass = rb_define_class_under(mQuickfix, "NoExpiration", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoExpiration, (void *) &SwigClassNoExpiration);
  rb_define_alloc_func(SwigClassNoExpiration.klass, _wrap_NoExpiration_allocate);
  rb_define_method(SwigClassNoExpiration.klass, "initialize", VALUEFUNC(_wrap_new_NoExpiration), -1);
  SwigClassNoExpiration.mark = 0;
  SwigClassNoExpiration.destroy = (void (*)(void *)) free_FIX_NoExpiration;
  SwigClassNoExpiration.trackObjects = 0;
  
  SwigClassTargetCompID.klass = rb_define_class_under(mQuickfix, "TargetCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetCompID, (void *) &SwigClassTargetCompID);
  rb_define_alloc_func(SwigClassTargetCompID.klass, _wrap_TargetCompID_allocate);
  rb_define_method(SwigClassTargetCompID.klass, "initialize", VALUEFUNC(_wrap_new_TargetCompID), -1);
  SwigClassTargetCompID.mark = 0;
  SwigClassTargetCompID.destroy = (void (*)(void *)) free_FIX_TargetCompID;
  SwigClassTargetCompID.trackObjects = 0;
  
  SwigClassMDEntryBuyer.klass = rb_define_class_under(mQuickfix, "MDEntryBuyer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryBuyer, (void *) &SwigClassMDEntryBuyer);
  rb_define_alloc_func(SwigClassMDEntryBuyer.klass, _wrap_MDEntryBuyer_allocate);
  rb_define_method(SwigClassMDEntryBuyer.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryBuyer), -1);
  SwigClassMDEntryBuyer.mark = 0;
  SwigClassMDEntryBuyer.destroy = (void (*)(void *)) free_FIX_MDEntryBuyer;
  SwigClassMDEntryBuyer.trackObjects = 0;
  
  SwigClassNoDerivativeInstrumentPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoDerivativeInstrumentPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs, (void *) &SwigClassNoDerivativeInstrumentPartySubIDs);
  rb_define_alloc_func(SwigClassNoDerivativeInstrumentPartySubIDs.klass, _wrap_NoDerivativeInstrumentPartySubIDs_allocate);
  rb_define_method(SwigClassNoDerivativeInstrumentPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeInstrumentPartySubIDs), -1);
  SwigClassNoDerivativeInstrumentPartySubIDs.mark = 0;
  SwigClassNoDerivativeInstrumentPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoDerivativeInstrumentPartySubIDs;
  SwigClassNoDerivativeInstrumentPartySubIDs.trackObjects = 0;
  
  SwigClassNoMaturityRules.klass = rb_define_class_under(mQuickfix, "NoMaturityRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMaturityRules, (void *) &SwigClassNoMaturityRules);
  rb_define_alloc_func(SwigClassNoMaturityRules.klass, _wrap_NoMaturityRules_allocate);
  rb_define_method(SwigClassNoMaturityRules.klass, "initialize", VALUEFUNC(_wrap_new_NoMaturityRules), -1);
  SwigClassNoMaturityRules.mark = 0;
  SwigClassNoMaturityRules.destroy = (void (*)(void *)) free_FIX_NoMaturityRules;
  SwigClassNoMaturityRules.trackObjects = 0;
  
  SwigClassQuoteMsgID.klass = rb_define_class_under(mQuickfix, "QuoteMsgID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteMsgID, (void *) &SwigClassQuoteMsgID);
  rb_define_alloc_func(SwigClassQuoteMsgID.klass, _wrap_QuoteMsgID_allocate);
  rb_define_method(SwigClassQuoteMsgID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteMsgID), -1);
  SwigClassQuoteMsgID.mark = 0;
  SwigClassQuoteMsgID.destroy = (void (*)(void *)) free_FIX_QuoteMsgID;
  SwigClassQuoteMsgID.trackObjects = 0;
  
  SwigClassTriggerType.klass = rb_define_class_under(mQuickfix, "TriggerType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerType, (void *) &SwigClassTriggerType);
  rb_define_alloc_func(SwigClassTriggerType.klass, _wrap_TriggerType_allocate);
  rb_define_method(SwigClassTriggerType.klass, "initialize", VALUEFUNC(_wrap_new_TriggerType), -1);
  SwigClassTriggerType.mark = 0;
  SwigClassTriggerType.destroy = (void (*)(void *)) free_FIX_TriggerType;
  SwigClassTriggerType.trackObjects = 0;
  
  SwigClassPriceProtectionScope.klass = rb_define_class_under(mQuickfix, "PriceProtectionScope", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceProtectionScope, (void *) &SwigClassPriceProtectionScope);
  rb_define_alloc_func(SwigClassPriceProtectionScope.klass, _wrap_PriceProtectionScope_allocate);
  rb_define_method(SwigClassPriceProtectionScope.klass, "initialize", VALUEFUNC(_wrap_new_PriceProtectionScope), -1);
  SwigClassPriceProtectionScope.mark = 0;
  SwigClassPriceProtectionScope.destroy = (void (*)(void *)) free_FIX_PriceProtectionScope;
  SwigClassPriceProtectionScope.trackObjects = 0;
  
  SwigClassTotNumAssignmentReports.klass = rb_define_class_under(mQuickfix, "TotNumAssignmentReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNumAssignmentReports, (void *) &SwigClassTotNumAssignmentReports);
  rb_define_alloc_func(SwigClassTotNumAssignmentReports.klass, _wrap_TotNumAssignmentReports_allocate);
  rb_define_method(SwigClassTotNumAssignmentReports.klass, "initialize", VALUEFUNC(_wrap_new_TotNumAssignmentReports), -1);
  SwigClassTotNumAssignmentReports.mark = 0;
  SwigClassTotNumAssignmentReports.destroy = (void (*)(void *)) free_FIX_TotNumAssignmentReports;
  SwigClassTotNumAssignmentReports.trackObjects = 0;
  
  SwigClassContraLegRefID.klass = rb_define_class_under(mQuickfix, "ContraLegRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraLegRefID, (void *) &SwigClassContraLegRefID);
  rb_define_alloc_func(SwigClassContraLegRefID.klass, _wrap_ContraLegRefID_allocate);
  rb_define_method(SwigClassContraLegRefID.klass, "initialize", VALUEFUNC(_wrap_new_ContraLegRefID), -1);
  SwigClassContraLegRefID.mark = 0;
  SwigClassContraLegRefID.destroy = (void (*)(void *)) free_FIX_ContraLegRefID;
  SwigClassContraLegRefID.trackObjects = 0;
  
  SwigClassTradeReportRejectReason.klass = rb_define_class_under(mQuickfix, "TradeReportRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportRejectReason, (void *) &SwigClassTradeReportRejectReason);
  rb_define_alloc_func(SwigClassTradeReportRejectReason.klass, _wrap_TradeReportRejectReason_allocate);
  rb_define_method(SwigClassTradeReportRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportRejectReason), -1);
  SwigClassTradeReportRejectReason.mark = 0;
  SwigClassTradeReportRejectReason.destroy = (void (*)(void *)) free_FIX_TradeReportRejectReason;
  SwigClassTradeReportRejectReason.trackObjects = 0;
  
  SwigClassTradeReportRefID.klass = rb_define_class_under(mQuickfix, "TradeReportRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportRefID, (void *) &SwigClassTradeReportRefID);
  rb_define_alloc_func(SwigClassTradeReportRefID.klass, _wrap_TradeReportRefID_allocate);
  rb_define_method(SwigClassTradeReportRefID.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportRefID), -1);
  SwigClassTradeReportRefID.mark = 0;
  SwigClassTradeReportRefID.destroy = (void (*)(void *)) free_FIX_TradeReportRefID;
  SwigClassTradeReportRefID.trackObjects = 0;
  
  SwigClassSecurityListType.klass = rb_define_class_under(mQuickfix, "SecurityListType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListType, (void *) &SwigClassSecurityListType);
  rb_define_alloc_func(SwigClassSecurityListType.klass, _wrap_SecurityListType_allocate);
  rb_define_method(SwigClassSecurityListType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListType), -1);
  SwigClassSecurityListType.mark = 0;
  SwigClassSecurityListType.destroy = (void (*)(void *)) free_FIX_SecurityListType;
  SwigClassSecurityListType.trackObjects = 0;
  
  SwigClassDerivativeSecurityIDSource.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityIDSource, (void *) &SwigClassDerivativeSecurityIDSource);
  rb_define_alloc_func(SwigClassDerivativeSecurityIDSource.klass, _wrap_DerivativeSecurityIDSource_allocate);
  rb_define_method(SwigClassDerivativeSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityIDSource), -1);
  SwigClassDerivativeSecurityIDSource.mark = 0;
  SwigClassDerivativeSecurityIDSource.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityIDSource;
  SwigClassDerivativeSecurityIDSource.trackObjects = 0;
  
  SwigClassAssignmentUnit.klass = rb_define_class_under(mQuickfix, "AssignmentUnit", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AssignmentUnit, (void *) &SwigClassAssignmentUnit);
  rb_define_alloc_func(SwigClassAssignmentUnit.klass, _wrap_AssignmentUnit_allocate);
  rb_define_method(SwigClassAssignmentUnit.klass, "initialize", VALUEFUNC(_wrap_new_AssignmentUnit), -1);
  SwigClassAssignmentUnit.mark = 0;
  SwigClassAssignmentUnit.destroy = (void (*)(void *)) free_FIX_AssignmentUnit;
  SwigClassAssignmentUnit.trackObjects = 0;
  
  SwigClassTradeReportID.klass = rb_define_class_under(mQuickfix, "TradeReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportID, (void *) &SwigClassTradeReportID);
  rb_define_alloc_func(SwigClassTradeReportID.klass, _wrap_TradeReportID_allocate);
  rb_define_method(SwigClassTradeReportID.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportID), -1);
  SwigClassTradeReportID.mark = 0;
  SwigClassTradeReportID.destroy = (void (*)(void *)) free_FIX_TradeReportID;
  SwigClassTradeReportID.trackObjects = 0;
  
  SwigClassNoRpts.klass = rb_define_class_under(mQuickfix, "NoRpts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRpts, (void *) &SwigClassNoRpts);
  rb_define_alloc_func(SwigClassNoRpts.klass, _wrap_NoRpts_allocate);
  rb_define_method(SwigClassNoRpts.klass, "initialize", VALUEFUNC(_wrap_new_NoRpts), -1);
  SwigClassNoRpts.mark = 0;
  SwigClassNoRpts.destroy = (void (*)(void *)) free_FIX_NoRpts;
  SwigClassNoRpts.trackObjects = 0;
  
  SwigClassLegBenchmarkPriceType.klass = rb_define_class_under(mQuickfix, "LegBenchmarkPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkPriceType, (void *) &SwigClassLegBenchmarkPriceType);
  rb_define_alloc_func(SwigClassLegBenchmarkPriceType.klass, _wrap_LegBenchmarkPriceType_allocate);
  rb_define_method(SwigClassLegBenchmarkPriceType.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkPriceType), -1);
  SwigClassLegBenchmarkPriceType.mark = 0;
  SwigClassLegBenchmarkPriceType.destroy = (void (*)(void *)) free_FIX_LegBenchmarkPriceType;
  SwigClassLegBenchmarkPriceType.trackObjects = 0;
  
  SwigClassEncodedSubjectLen.klass = rb_define_class_under(mQuickfix, "EncodedSubjectLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSubjectLen, (void *) &SwigClassEncodedSubjectLen);
  rb_define_alloc_func(SwigClassEncodedSubjectLen.klass, _wrap_EncodedSubjectLen_allocate);
  rb_define_method(SwigClassEncodedSubjectLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSubjectLen), -1);
  SwigClassEncodedSubjectLen.mark = 0;
  SwigClassEncodedSubjectLen.destroy = (void (*)(void *)) free_FIX_EncodedSubjectLen;
  SwigClassEncodedSubjectLen.trackObjects = 0;
  
  SwigClassSecurityXML.klass = rb_define_class_under(mQuickfix, "SecurityXML", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityXML, (void *) &SwigClassSecurityXML);
  rb_define_alloc_func(SwigClassSecurityXML.klass, _wrap_SecurityXML_allocate);
  rb_define_method(SwigClassSecurityXML.klass, "initialize", VALUEFUNC(_wrap_new_SecurityXML), -1);
  SwigClassSecurityXML.mark = 0;
  SwigClassSecurityXML.destroy = (void (*)(void *)) free_FIX_SecurityXML;
  SwigClassSecurityXML.trackObjects = 0;
  
  SwigClassLegReportID.klass = rb_define_class_under(mQuickfix, "LegReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegReportID, (void *) &SwigClassLegReportID);
  rb_define_alloc_func(SwigClassLegReportID.klass, _wrap_LegReportID_allocate);
  rb_define_method(SwigClassLegReportID.klass, "initialize", VALUEFUNC(_wrap_new_LegReportID), -1);
  SwigClassLegReportID.mark = 0;
  SwigClassLegReportID.destroy = (void (*)(void *)) free_FIX_LegReportID;
  SwigClassLegReportID.trackObjects = 0;
  
  SwigClassNested3PartySubIDType.klass = rb_define_class_under(mQuickfix, "Nested3PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartySubIDType, (void *) &SwigClassNested3PartySubIDType);
  rb_define_alloc_func(SwigClassNested3PartySubIDType.klass, _wrap_Nested3PartySubIDType_allocate);
  rb_define_method(SwigClassNested3PartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartySubIDType), -1);
  SwigClassNested3PartySubIDType.mark = 0;
  SwigClassNested3PartySubIDType.destroy = (void (*)(void *)) free_FIX_Nested3PartySubIDType;
  SwigClassNested3PartySubIDType.trackObjects = 0;
  
  SwigClassBenchmarkSecurityIDSource.klass = rb_define_class_under(mQuickfix, "BenchmarkSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkSecurityIDSource, (void *) &SwigClassBenchmarkSecurityIDSource);
  rb_define_alloc_func(SwigClassBenchmarkSecurityIDSource.klass, _wrap_BenchmarkSecurityIDSource_allocate);
  rb_define_method(SwigClassBenchmarkSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkSecurityIDSource), -1);
  SwigClassBenchmarkSecurityIDSource.mark = 0;
  SwigClassBenchmarkSecurityIDSource.destroy = (void (*)(void *)) free_FIX_BenchmarkSecurityIDSource;
  SwigClassBenchmarkSecurityIDSource.trackObjects = 0;
  
  SwigClassQuoteRejectReason.klass = rb_define_class_under(mQuickfix, "QuoteRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRejectReason, (void *) &SwigClassQuoteRejectReason);
  rb_define_alloc_func(SwigClassQuoteRejectReason.klass, _wrap_QuoteRejectReason_allocate);
  rb_define_method(SwigClassQuoteRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRejectReason), -1);
  SwigClassQuoteRejectReason.mark = 0;
  SwigClassQuoteRejectReason.destroy = (void (*)(void *)) free_FIX_QuoteRejectReason;
  SwigClassQuoteRejectReason.trackObjects = 0;
  
  SwigClassHeartBtInt.klass = rb_define_class_under(mQuickfix, "HeartBtInt", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HeartBtInt, (void *) &SwigClassHeartBtInt);
  rb_define_alloc_func(SwigClassHeartBtInt.klass, _wrap_HeartBtInt_allocate);
  rb_define_method(SwigClassHeartBtInt.klass, "initialize", VALUEFUNC(_wrap_new_HeartBtInt), -1);
  SwigClassHeartBtInt.mark = 0;
  SwigClassHeartBtInt.destroy = (void (*)(void *)) free_FIX_HeartBtInt;
  SwigClassHeartBtInt.trackObjects = 0;
  
  SwigClassBidForwardPoints.klass = rb_define_class_under(mQuickfix, "BidForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidForwardPoints, (void *) &SwigClassBidForwardPoints);
  rb_define_alloc_func(SwigClassBidForwardPoints.klass, _wrap_BidForwardPoints_allocate);
  rb_define_method(SwigClassBidForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_BidForwardPoints), -1);
  SwigClassBidForwardPoints.mark = 0;
  SwigClassBidForwardPoints.destroy = (void (*)(void *)) free_FIX_BidForwardPoints;
  SwigClassBidForwardPoints.trackObjects = 0;
  
  SwigClassPossResend.klass = rb_define_class_under(mQuickfix, "PossResend", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PossResend, (void *) &SwigClassPossResend);
  rb_define_alloc_func(SwigClassPossResend.klass, _wrap_PossResend_allocate);
  rb_define_method(SwigClassPossResend.klass, "initialize", VALUEFUNC(_wrap_new_PossResend), -1);
  SwigClassPossResend.mark = 0;
  SwigClassPossResend.destroy = (void (*)(void *)) free_FIX_PossResend;
  SwigClassPossResend.trackObjects = 0;
  
  SwigClassSymbol.klass = rb_define_class_under(mQuickfix, "Symbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Symbol, (void *) &SwigClassSymbol);
  rb_define_alloc_func(SwigClassSymbol.klass, _wrap_Symbol_allocate);
  rb_define_method(SwigClassSymbol.klass, "initialize", VALUEFUNC(_wrap_new_Symbol), -1);
  SwigClassSymbol.mark = 0;
  SwigClassSymbol.destroy = (void (*)(void *)) free_FIX_Symbol;
  SwigClassSymbol.trackObjects = 0;
  
  SwigClassEncodedUnderlyingSecurityDesc.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc, (void *) &SwigClassEncodedUnderlyingSecurityDesc);
  rb_define_alloc_func(SwigClassEncodedUnderlyingSecurityDesc.klass, _wrap_EncodedUnderlyingSecurityDesc_allocate);
  rb_define_method(SwigClassEncodedUnderlyingSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingSecurityDesc), -1);
  SwigClassEncodedUnderlyingSecurityDesc.mark = 0;
  SwigClassEncodedUnderlyingSecurityDesc.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingSecurityDesc;
  SwigClassEncodedUnderlyingSecurityDesc.trackObjects = 0;
  
  SwigClassMarketReportID.klass = rb_define_class_under(mQuickfix, "MarketReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketReportID, (void *) &SwigClassMarketReportID);
  rb_define_alloc_func(SwigClassMarketReportID.klass, _wrap_MarketReportID_allocate);
  rb_define_method(SwigClassMarketReportID.klass, "initialize", VALUEFUNC(_wrap_new_MarketReportID), -1);
  SwigClassMarketReportID.mark = 0;
  SwigClassMarketReportID.destroy = (void (*)(void *)) free_FIX_MarketReportID;
  SwigClassMarketReportID.trackObjects = 0;
  
  SwigClassDiscretionPrice.klass = rb_define_class_under(mQuickfix, "DiscretionPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionPrice, (void *) &SwigClassDiscretionPrice);
  rb_define_alloc_func(SwigClassDiscretionPrice.klass, _wrap_DiscretionPrice_allocate);
  rb_define_method(SwigClassDiscretionPrice.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionPrice), -1);
  SwigClassDiscretionPrice.mark = 0;
  SwigClassDiscretionPrice.destroy = (void (*)(void *)) free_FIX_DiscretionPrice;
  SwigClassDiscretionPrice.trackObjects = 0;
  
  SwigClassContAmtValue.klass = rb_define_class_under(mQuickfix, "ContAmtValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContAmtValue, (void *) &SwigClassContAmtValue);
  rb_define_alloc_func(SwigClassContAmtValue.klass, _wrap_ContAmtValue_allocate);
  rb_define_method(SwigClassContAmtValue.klass, "initialize", VALUEFUNC(_wrap_new_ContAmtValue), -1);
  SwigClassContAmtValue.mark = 0;
  SwigClassContAmtValue.destroy = (void (*)(void *)) free_FIX_ContAmtValue;
  SwigClassContAmtValue.trackObjects = 0;
  
  SwigClassQuantityType.klass = rb_define_class_under(mQuickfix, "QuantityType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuantityType, (void *) &SwigClassQuantityType);
  rb_define_alloc_func(SwigClassQuantityType.klass, _wrap_QuantityType_allocate);
  rb_define_method(SwigClassQuantityType.klass, "initialize", VALUEFUNC(_wrap_new_QuantityType), -1);
  SwigClassQuantityType.mark = 0;
  SwigClassQuantityType.destroy = (void (*)(void *)) free_FIX_QuantityType;
  SwigClassQuantityType.trackObjects = 0;
  
  SwigClassComplexEventPriceBoundaryMethod.klass = rb_define_class_under(mQuickfix, "ComplexEventPriceBoundaryMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod, (void *) &SwigClassComplexEventPriceBoundaryMethod);
  rb_define_alloc_func(SwigClassComplexEventPriceBoundaryMethod.klass, _wrap_ComplexEventPriceBoundaryMethod_allocate);
  rb_define_method(SwigClassComplexEventPriceBoundaryMethod.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPriceBoundaryMethod), -1);
  SwigClassComplexEventPriceBoundaryMethod.mark = 0;
  SwigClassComplexEventPriceBoundaryMethod.destroy = (void (*)(void *)) free_FIX_ComplexEventPriceBoundaryMethod;
  SwigClassComplexEventPriceBoundaryMethod.trackObjects = 0;
  
  SwigClassImpliedMarketIndicator.klass = rb_define_class_under(mQuickfix, "ImpliedMarketIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ImpliedMarketIndicator, (void *) &SwigClassImpliedMarketIndicator);
  rb_define_alloc_func(SwigClassImpliedMarketIndicator.klass, _wrap_ImpliedMarketIndicator_allocate);
  rb_define_method(SwigClassImpliedMarketIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ImpliedMarketIndicator), -1);
  SwigClassImpliedMarketIndicator.mark = 0;
  SwigClassImpliedMarketIndicator.destroy = (void (*)(void *)) free_FIX_ImpliedMarketIndicator;
  SwigClassImpliedMarketIndicator.trackObjects = 0;
  
  SwigClassAllocClearingFeeIndicator.klass = rb_define_class_under(mQuickfix, "AllocClearingFeeIndicator", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocClearingFeeIndicator, (void *) &SwigClassAllocClearingFeeIndicator);
  rb_define_alloc_func(SwigClassAllocClearingFeeIndicator.klass, _wrap_AllocClearingFeeIndicator_allocate);
  rb_define_method(SwigClassAllocClearingFeeIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AllocClearingFeeIndicator), -1);
  SwigClassAllocClearingFeeIndicator.mark = 0;
  SwigClassAllocClearingFeeIndicator.destroy = (void (*)(void *)) free_FIX_AllocClearingFeeIndicator;
  SwigClassAllocClearingFeeIndicator.trackObjects = 0;
  
  SwigClassQuoteRequestType.klass = rb_define_class_under(mQuickfix, "QuoteRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRequestType, (void *) &SwigClassQuoteRequestType);
  rb_define_alloc_func(SwigClassQuoteRequestType.klass, _wrap_QuoteRequestType_allocate);
  rb_define_method(SwigClassQuoteRequestType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRequestType), -1);
  SwigClassQuoteRequestType.mark = 0;
  SwigClassQuoteRequestType.destroy = (void (*)(void *)) free_FIX_QuoteRequestType;
  SwigClassQuoteRequestType.trackObjects = 0;
  
  SwigClassSecurityRequestResult.klass = rb_define_class_under(mQuickfix, "SecurityRequestResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityRequestResult, (void *) &SwigClassSecurityRequestResult);
  rb_define_alloc_func(SwigClassSecurityRequestResult.klass, _wrap_SecurityRequestResult_allocate);
  rb_define_method(SwigClassSecurityRequestResult.klass, "initialize", VALUEFUNC(_wrap_new_SecurityRequestResult), -1);
  SwigClassSecurityRequestResult.mark = 0;
  SwigClassSecurityRequestResult.destroy = (void (*)(void *)) free_FIX_SecurityRequestResult;
  SwigClassSecurityRequestResult.trackObjects = 0;
  
  SwigClassOrderRestrictions.klass = rb_define_class_under(mQuickfix, "OrderRestrictions", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderRestrictions, (void *) &SwigClassOrderRestrictions);
  rb_define_alloc_func(SwigClassOrderRestrictions.klass, _wrap_OrderRestrictions_allocate);
  rb_define_method(SwigClassOrderRestrictions.klass, "initialize", VALUEFUNC(_wrap_new_OrderRestrictions), -1);
  SwigClassOrderRestrictions.mark = 0;
  SwigClassOrderRestrictions.destroy = (void (*)(void *)) free_FIX_OrderRestrictions;
  SwigClassOrderRestrictions.trackObjects = 0;
  
  SwigClassNoSideTrdRegTS.klass = rb_define_class_under(mQuickfix, "NoSideTrdRegTS", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSideTrdRegTS, (void *) &SwigClassNoSideTrdRegTS);
  rb_define_alloc_func(SwigClassNoSideTrdRegTS.klass, _wrap_NoSideTrdRegTS_allocate);
  rb_define_method(SwigClassNoSideTrdRegTS.klass, "initialize", VALUEFUNC(_wrap_new_NoSideTrdRegTS), -1);
  SwigClassNoSideTrdRegTS.mark = 0;
  SwigClassNoSideTrdRegTS.destroy = (void (*)(void *)) free_FIX_NoSideTrdRegTS;
  SwigClassNoSideTrdRegTS.trackObjects = 0;
  
  SwigClassText.klass = rb_define_class_under(mQuickfix, "Text", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Text, (void *) &SwigClassText);
  rb_define_alloc_func(SwigClassText.klass, _wrap_Text_allocate);
  rb_define_method(SwigClassText.klass, "initialize", VALUEFUNC(_wrap_new_Text), -1);
  SwigClassText.mark = 0;
  SwigClassText.destroy = (void (*)(void *)) free_FIX_Text;
  SwigClassText.trackObjects = 0;
  
  SwigClassEncodedTextLen.klass = rb_define_class_under(mQuickfix, "EncodedTextLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedTextLen, (void *) &SwigClassEncodedTextLen);
  rb_define_alloc_func(SwigClassEncodedTextLen.klass, _wrap_EncodedTextLen_allocate);
  rb_define_method(SwigClassEncodedTextLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedTextLen), -1);
  SwigClassEncodedTextLen.mark = 0;
  SwigClassEncodedTextLen.destroy = (void (*)(void *)) free_FIX_EncodedTextLen;
  SwigClassEncodedTextLen.trackObjects = 0;
  
  SwigClassListExecInstType.klass = rb_define_class_under(mQuickfix, "ListExecInstType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListExecInstType, (void *) &SwigClassListExecInstType);
  rb_define_alloc_func(SwigClassListExecInstType.klass, _wrap_ListExecInstType_allocate);
  rb_define_method(SwigClassListExecInstType.klass, "initialize", VALUEFUNC(_wrap_new_ListExecInstType), -1);
  SwigClassListExecInstType.mark = 0;
  SwigClassListExecInstType.destroy = (void (*)(void *)) free_FIX_ListExecInstType;
  SwigClassListExecInstType.trackObjects = 0;
  
  SwigClassSecondaryOrderID.klass = rb_define_class_under(mQuickfix, "SecondaryOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryOrderID, (void *) &SwigClassSecondaryOrderID);
  rb_define_alloc_func(SwigClassSecondaryOrderID.klass, _wrap_SecondaryOrderID_allocate);
  rb_define_method(SwigClassSecondaryOrderID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryOrderID), -1);
  SwigClassSecondaryOrderID.mark = 0;
  SwigClassSecondaryOrderID.destroy = (void (*)(void *)) free_FIX_SecondaryOrderID;
  SwigClassSecondaryOrderID.trackObjects = 0;
  
  SwigClassExecBroker.klass = rb_define_class_under(mQuickfix, "ExecBroker", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecBroker, (void *) &SwigClassExecBroker);
  rb_define_alloc_func(SwigClassExecBroker.klass, _wrap_ExecBroker_allocate);
  rb_define_method(SwigClassExecBroker.klass, "initialize", VALUEFUNC(_wrap_new_ExecBroker), -1);
  SwigClassExecBroker.mark = 0;
  SwigClassExecBroker.destroy = (void (*)(void *)) free_FIX_ExecBroker;
  SwigClassExecBroker.trackObjects = 0;
  
  SwigClassSecurityXMLLen.klass = rb_define_class_under(mQuickfix, "SecurityXMLLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityXMLLen, (void *) &SwigClassSecurityXMLLen);
  rb_define_alloc_func(SwigClassSecurityXMLLen.klass, _wrap_SecurityXMLLen_allocate);
  rb_define_method(SwigClassSecurityXMLLen.klass, "initialize", VALUEFUNC(_wrap_new_SecurityXMLLen), -1);
  SwigClassSecurityXMLLen.mark = 0;
  SwigClassSecurityXMLLen.destroy = (void (*)(void *)) free_FIX_SecurityXMLLen;
  SwigClassSecurityXMLLen.trackObjects = 0;
  
  SwigClassApplSeqNum.klass = rb_define_class_under(mQuickfix, "ApplSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplSeqNum, (void *) &SwigClassApplSeqNum);
  rb_define_alloc_func(SwigClassApplSeqNum.klass, _wrap_ApplSeqNum_allocate);
  rb_define_method(SwigClassApplSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplSeqNum), -1);
  SwigClassApplSeqNum.mark = 0;
  SwigClassApplSeqNum.destroy = (void (*)(void *)) free_FIX_ApplSeqNum;
  SwigClassApplSeqNum.trackObjects = 0;
  
  SwigClassMaxTradeVol.klass = rb_define_class_under(mQuickfix, "MaxTradeVol", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxTradeVol, (void *) &SwigClassMaxTradeVol);
  rb_define_alloc_func(SwigClassMaxTradeVol.klass, _wrap_MaxTradeVol_allocate);
  rb_define_method(SwigClassMaxTradeVol.klass, "initialize", VALUEFUNC(_wrap_new_MaxTradeVol), -1);
  SwigClassMaxTradeVol.mark = 0;
  SwigClassMaxTradeVol.destroy = (void (*)(void *)) free_FIX_MaxTradeVol;
  SwigClassMaxTradeVol.trackObjects = 0;
  
  SwigClassOfferSwapPoints.klass = rb_define_class_under(mQuickfix, "OfferSwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferSwapPoints, (void *) &SwigClassOfferSwapPoints);
  rb_define_alloc_func(SwigClassOfferSwapPoints.klass, _wrap_OfferSwapPoints_allocate);
  rb_define_method(SwigClassOfferSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_OfferSwapPoints), -1);
  SwigClassOfferSwapPoints.mark = 0;
  SwigClassOfferSwapPoints.destroy = (void (*)(void *)) free_FIX_OfferSwapPoints;
  SwigClassOfferSwapPoints.trackObjects = 0;
  
  SwigClassSettlPartySubIDType.klass = rb_define_class_under(mQuickfix, "SettlPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartySubIDType, (void *) &SwigClassSettlPartySubIDType);
  rb_define_alloc_func(SwigClassSettlPartySubIDType.klass, _wrap_SettlPartySubIDType_allocate);
  rb_define_method(SwigClassSettlPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartySubIDType), -1);
  SwigClassSettlPartySubIDType.mark = 0;
  SwigClassSettlPartySubIDType.destroy = (void (*)(void *)) free_FIX_SettlPartySubIDType;
  SwigClassSettlPartySubIDType.trackObjects = 0;
  
  SwigClassDistribPaymentMethod.klass = rb_define_class_under(mQuickfix, "DistribPaymentMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DistribPaymentMethod, (void *) &SwigClassDistribPaymentMethod);
  rb_define_alloc_func(SwigClassDistribPaymentMethod.klass, _wrap_DistribPaymentMethod_allocate);
  rb_define_method(SwigClassDistribPaymentMethod.klass, "initialize", VALUEFUNC(_wrap_new_DistribPaymentMethod), -1);
  SwigClassDistribPaymentMethod.mark = 0;
  SwigClassDistribPaymentMethod.destroy = (void (*)(void *)) free_FIX_DistribPaymentMethod;
  SwigClassDistribPaymentMethod.trackObjects = 0;
  
  SwigClassTotalAffectedOrders.klass = rb_define_class_under(mQuickfix, "TotalAffectedOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalAffectedOrders, (void *) &SwigClassTotalAffectedOrders);
  rb_define_alloc_func(SwigClassTotalAffectedOrders.klass, _wrap_TotalAffectedOrders_allocate);
  rb_define_method(SwigClassTotalAffectedOrders.klass, "initialize", VALUEFUNC(_wrap_new_TotalAffectedOrders), -1);
  SwigClassTotalAffectedOrders.mark = 0;
  SwigClassTotalAffectedOrders.destroy = (void (*)(void *)) free_FIX_TotalAffectedOrders;
  SwigClassTotalAffectedOrders.trackObjects = 0;
  
  SwigClassStrikeIncrement.klass = rb_define_class_under(mQuickfix, "StrikeIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeIncrement, (void *) &SwigClassStrikeIncrement);
  rb_define_alloc_func(SwigClassStrikeIncrement.klass, _wrap_StrikeIncrement_allocate);
  rb_define_method(SwigClassStrikeIncrement.klass, "initialize", VALUEFUNC(_wrap_new_StrikeIncrement), -1);
  SwigClassStrikeIncrement.mark = 0;
  SwigClassStrikeIncrement.destroy = (void (*)(void *)) free_FIX_StrikeIncrement;
  SwigClassStrikeIncrement.trackObjects = 0;
  
  SwigClassOrderHandlingInstSource.klass = rb_define_class_under(mQuickfix, "OrderHandlingInstSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderHandlingInstSource, (void *) &SwigClassOrderHandlingInstSource);
  rb_define_alloc_func(SwigClassOrderHandlingInstSource.klass, _wrap_OrderHandlingInstSource_allocate);
  rb_define_method(SwigClassOrderHandlingInstSource.klass, "initialize", VALUEFUNC(_wrap_new_OrderHandlingInstSource), -1);
  SwigClassOrderHandlingInstSource.mark = 0;
  SwigClassOrderHandlingInstSource.destroy = (void (*)(void *)) free_FIX_OrderHandlingInstSource;
  SwigClassOrderHandlingInstSource.trackObjects = 0;
  
  SwigClassCopyMsgIndicator.klass = rb_define_class_under(mQuickfix, "CopyMsgIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CopyMsgIndicator, (void *) &SwigClassCopyMsgIndicator);
  rb_define_alloc_func(SwigClassCopyMsgIndicator.klass, _wrap_CopyMsgIndicator_allocate);
  rb_define_method(SwigClassCopyMsgIndicator.klass, "initialize", VALUEFUNC(_wrap_new_CopyMsgIndicator), -1);
  SwigClassCopyMsgIndicator.mark = 0;
  SwigClassCopyMsgIndicator.destroy = (void (*)(void *)) free_FIX_CopyMsgIndicator;
  SwigClassCopyMsgIndicator.trackObjects = 0;
  
  SwigClassNoDlvyInst.klass = rb_define_class_under(mQuickfix, "NoDlvyInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDlvyInst, (void *) &SwigClassNoDlvyInst);
  rb_define_alloc_func(SwigClassNoDlvyInst.klass, _wrap_NoDlvyInst_allocate);
  rb_define_method(SwigClassNoDlvyInst.klass, "initialize", VALUEFUNC(_wrap_new_NoDlvyInst), -1);
  SwigClassNoDlvyInst.mark = 0;
  SwigClassNoDlvyInst.destroy = (void (*)(void *)) free_FIX_NoDlvyInst;
  SwigClassNoDlvyInst.trackObjects = 0;
  
  SwigClassQuoteEntryID.klass = rb_define_class_under(mQuickfix, "QuoteEntryID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteEntryID, (void *) &SwigClassQuoteEntryID);
  rb_define_alloc_func(SwigClassQuoteEntryID.klass, _wrap_QuoteEntryID_allocate);
  rb_define_method(SwigClassQuoteEntryID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteEntryID), -1);
  SwigClassQuoteEntryID.mark = 0;
  SwigClassQuoteEntryID.destroy = (void (*)(void *)) free_FIX_QuoteEntryID;
  SwigClassQuoteEntryID.trackObjects = 0;
  
  SwigClassAffirmStatus.klass = rb_define_class_under(mQuickfix, "AffirmStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AffirmStatus, (void *) &SwigClassAffirmStatus);
  rb_define_alloc_func(SwigClassAffirmStatus.klass, _wrap_AffirmStatus_allocate);
  rb_define_method(SwigClassAffirmStatus.klass, "initialize", VALUEFUNC(_wrap_new_AffirmStatus), -1);
  SwigClassAffirmStatus.mark = 0;
  SwigClassAffirmStatus.destroy = (void (*)(void *)) free_FIX_AffirmStatus;
  SwigClassAffirmStatus.trackObjects = 0;
  
  SwigClassMailingInst.klass = rb_define_class_under(mQuickfix, "MailingInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MailingInst, (void *) &SwigClassMailingInst);
  rb_define_alloc_func(SwigClassMailingInst.klass, _wrap_MailingInst_allocate);
  rb_define_method(SwigClassMailingInst.klass, "initialize", VALUEFUNC(_wrap_new_MailingInst), -1);
  SwigClassMailingInst.mark = 0;
  SwigClassMailingInst.destroy = (void (*)(void *)) free_FIX_MailingInst;
  SwigClassMailingInst.trackObjects = 0;
  
  SwigClassOfferSize.klass = rb_define_class_under(mQuickfix, "OfferSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferSize, (void *) &SwigClassOfferSize);
  rb_define_alloc_func(SwigClassOfferSize.klass, _wrap_OfferSize_allocate);
  rb_define_method(SwigClassOfferSize.klass, "initialize", VALUEFUNC(_wrap_new_OfferSize), -1);
  SwigClassOfferSize.mark = 0;
  SwigClassOfferSize.destroy = (void (*)(void *)) free_FIX_OfferSize;
  SwigClassOfferSize.trackObjects = 0;
  
  SwigClassLegSecurityType.klass = rb_define_class_under(mQuickfix, "LegSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityType, (void *) &SwigClassLegSecurityType);
  rb_define_alloc_func(SwigClassLegSecurityType.klass, _wrap_LegSecurityType_allocate);
  rb_define_method(SwigClassLegSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityType), -1);
  SwigClassLegSecurityType.mark = 0;
  SwigClassLegSecurityType.destroy = (void (*)(void *)) free_FIX_LegSecurityType;
  SwigClassLegSecurityType.trackObjects = 0;
  
  SwigClassOrigCustOrderCapacity.klass = rb_define_class_under(mQuickfix, "OrigCustOrderCapacity", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigCustOrderCapacity, (void *) &SwigClassOrigCustOrderCapacity);
  rb_define_alloc_func(SwigClassOrigCustOrderCapacity.klass, _wrap_OrigCustOrderCapacity_allocate);
  rb_define_method(SwigClassOrigCustOrderCapacity.klass, "initialize", VALUEFUNC(_wrap_new_OrigCustOrderCapacity), -1);
  SwigClassOrigCustOrderCapacity.mark = 0;
  SwigClassOrigCustOrderCapacity.destroy = (void (*)(void *)) free_FIX_OrigCustOrderCapacity;
  SwigClassOrigCustOrderCapacity.trackObjects = 0;
  
  SwigClassAllocMethod.klass = rb_define_class_under(mQuickfix, "AllocMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocMethod, (void *) &SwigClassAllocMethod);
  rb_define_alloc_func(SwigClassAllocMethod.klass, _wrap_AllocMethod_allocate);
  rb_define_method(SwigClassAllocMethod.klass, "initialize", VALUEFUNC(_wrap_new_AllocMethod), -1);
  SwigClassAllocMethod.mark = 0;
  SwigClassAllocMethod.destroy = (void (*)(void *)) free_FIX_AllocMethod;
  SwigClassAllocMethod.trackObjects = 0;
  
  SwigClassQuantityDate.klass = rb_define_class_under(mQuickfix, "QuantityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuantityDate, (void *) &SwigClassQuantityDate);
  rb_define_alloc_func(SwigClassQuantityDate.klass, _wrap_QuantityDate_allocate);
  rb_define_method(SwigClassQuantityDate.klass, "initialize", VALUEFUNC(_wrap_new_QuantityDate), -1);
  SwigClassQuantityDate.mark = 0;
  SwigClassQuantityDate.destroy = (void (*)(void *)) free_FIX_QuantityDate;
  SwigClassQuantityDate.trackObjects = 0;
  
  SwigClassTargetStrategyPerformance.klass = rb_define_class_under(mQuickfix, "TargetStrategyPerformance", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetStrategyPerformance, (void *) &SwigClassTargetStrategyPerformance);
  rb_define_alloc_func(SwigClassTargetStrategyPerformance.klass, _wrap_TargetStrategyPerformance_allocate);
  rb_define_method(SwigClassTargetStrategyPerformance.klass, "initialize", VALUEFUNC(_wrap_new_TargetStrategyPerformance), -1);
  SwigClassTargetStrategyPerformance.mark = 0;
  SwigClassTargetStrategyPerformance.destroy = (void (*)(void *)) free_FIX_TargetStrategyPerformance;
  SwigClassTargetStrategyPerformance.trackObjects = 0;
  
  SwigClassCardExpDate.klass = rb_define_class_under(mQuickfix, "CardExpDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardExpDate, (void *) &SwigClassCardExpDate);
  rb_define_alloc_func(SwigClassCardExpDate.klass, _wrap_CardExpDate_allocate);
  rb_define_method(SwigClassCardExpDate.klass, "initialize", VALUEFUNC(_wrap_new_CardExpDate), -1);
  SwigClassCardExpDate.mark = 0;
  SwigClassCardExpDate.destroy = (void (*)(void *)) free_FIX_CardExpDate;
  SwigClassCardExpDate.trackObjects = 0;
  
  SwigClassConfirmID.klass = rb_define_class_under(mQuickfix, "ConfirmID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmID, (void *) &SwigClassConfirmID);
  rb_define_alloc_func(SwigClassConfirmID.klass, _wrap_ConfirmID_allocate);
  rb_define_method(SwigClassConfirmID.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmID), -1);
  SwigClassConfirmID.mark = 0;
  SwigClassConfirmID.destroy = (void (*)(void *)) free_FIX_ConfirmID;
  SwigClassConfirmID.trackObjects = 0;
  
  SwigClassStandInstDbName.klass = rb_define_class_under(mQuickfix, "StandInstDbName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StandInstDbName, (void *) &SwigClassStandInstDbName);
  rb_define_alloc_func(SwigClassStandInstDbName.klass, _wrap_StandInstDbName_allocate);
  rb_define_method(SwigClassStandInstDbName.klass, "initialize", VALUEFUNC(_wrap_new_StandInstDbName), -1);
  SwigClassStandInstDbName.mark = 0;
  SwigClassStandInstDbName.destroy = (void (*)(void *)) free_FIX_StandInstDbName;
  SwigClassStandInstDbName.trackObjects = 0;
  
  SwigClassDayOrderQty.klass = rb_define_class_under(mQuickfix, "DayOrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayOrderQty, (void *) &SwigClassDayOrderQty);
  rb_define_alloc_func(SwigClassDayOrderQty.klass, _wrap_DayOrderQty_allocate);
  rb_define_method(SwigClassDayOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_DayOrderQty), -1);
  SwigClassDayOrderQty.mark = 0;
  SwigClassDayOrderQty.destroy = (void (*)(void *)) free_FIX_DayOrderQty;
  SwigClassDayOrderQty.trackObjects = 0;
  
  SwigClassHighLimitPrice.klass = rb_define_class_under(mQuickfix, "HighLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HighLimitPrice, (void *) &SwigClassHighLimitPrice);
  rb_define_alloc_func(SwigClassHighLimitPrice.klass, _wrap_HighLimitPrice_allocate);
  rb_define_method(SwigClassHighLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_HighLimitPrice), -1);
  SwigClassHighLimitPrice.mark = 0;
  SwigClassHighLimitPrice.destroy = (void (*)(void *)) free_FIX_HighLimitPrice;
  SwigClassHighLimitPrice.trackObjects = 0;
  
  SwigClassFirmTradeID.klass = rb_define_class_under(mQuickfix, "FirmTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FirmTradeID, (void *) &SwigClassFirmTradeID);
  rb_define_alloc_func(SwigClassFirmTradeID.klass, _wrap_FirmTradeID_allocate);
  rb_define_method(SwigClassFirmTradeID.klass, "initialize", VALUEFUNC(_wrap_new_FirmTradeID), -1);
  SwigClassFirmTradeID.mark = 0;
  SwigClassFirmTradeID.destroy = (void (*)(void *)) free_FIX_FirmTradeID;
  SwigClassFirmTradeID.trackObjects = 0;
  
  SwigClassSecondaryIndividualAllocID.klass = rb_define_class_under(mQuickfix, "SecondaryIndividualAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryIndividualAllocID, (void *) &SwigClassSecondaryIndividualAllocID);
  rb_define_alloc_func(SwigClassSecondaryIndividualAllocID.klass, _wrap_SecondaryIndividualAllocID_allocate);
  rb_define_method(SwigClassSecondaryIndividualAllocID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryIndividualAllocID), -1);
  SwigClassSecondaryIndividualAllocID.mark = 0;
  SwigClassSecondaryIndividualAllocID.destroy = (void (*)(void *)) free_FIX_SecondaryIndividualAllocID;
  SwigClassSecondaryIndividualAllocID.trackObjects = 0;
  
  SwigClassAgreementDesc.klass = rb_define_class_under(mQuickfix, "AgreementDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementDesc, (void *) &SwigClassAgreementDesc);
  rb_define_alloc_func(SwigClassAgreementDesc.klass, _wrap_AgreementDesc_allocate);
  rb_define_method(SwigClassAgreementDesc.klass, "initialize", VALUEFUNC(_wrap_new_AgreementDesc), -1);
  SwigClassAgreementDesc.mark = 0;
  SwigClassAgreementDesc.destroy = (void (*)(void *)) free_FIX_AgreementDesc;
  SwigClassAgreementDesc.trackObjects = 0;
  
  SwigClassMassCancelResponse.klass = rb_define_class_under(mQuickfix, "MassCancelResponse", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassCancelResponse, (void *) &SwigClassMassCancelResponse);
  rb_define_alloc_func(SwigClassMassCancelResponse.klass, _wrap_MassCancelResponse_allocate);
  rb_define_method(SwigClassMassCancelResponse.klass, "initialize", VALUEFUNC(_wrap_new_MassCancelResponse), -1);
  SwigClassMassCancelResponse.mark = 0;
  SwigClassMassCancelResponse.destroy = (void (*)(void *)) free_FIX_MassCancelResponse;
  SwigClassMassCancelResponse.trackObjects = 0;
  
  SwigClassLegSettlCurrency.klass = rb_define_class_under(mQuickfix, "LegSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlCurrency, (void *) &SwigClassLegSettlCurrency);
  rb_define_alloc_func(SwigClassLegSettlCurrency.klass, _wrap_LegSettlCurrency_allocate);
  rb_define_method(SwigClassLegSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlCurrency), -1);
  SwigClassLegSettlCurrency.mark = 0;
  SwigClassLegSettlCurrency.destroy = (void (*)(void *)) free_FIX_LegSettlCurrency;
  SwigClassLegSettlCurrency.trackObjects = 0;
  
  SwigClassCommission.klass = rb_define_class_under(mQuickfix, "Commission", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Commission, (void *) &SwigClassCommission);
  rb_define_alloc_func(SwigClassCommission.klass, _wrap_Commission_allocate);
  rb_define_method(SwigClassCommission.klass, "initialize", VALUEFUNC(_wrap_new_Commission), -1);
  SwigClassCommission.mark = 0;
  SwigClassCommission.destroy = (void (*)(void *)) free_FIX_Commission;
  SwigClassCommission.trackObjects = 0;
  
  SwigClassStreamAsgnReqType.klass = rb_define_class_under(mQuickfix, "StreamAsgnReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnReqType, (void *) &SwigClassStreamAsgnReqType);
  rb_define_alloc_func(SwigClassStreamAsgnReqType.klass, _wrap_StreamAsgnReqType_allocate);
  rb_define_method(SwigClassStreamAsgnReqType.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnReqType), -1);
  SwigClassStreamAsgnReqType.mark = 0;
  SwigClassStreamAsgnReqType.destroy = (void (*)(void *)) free_FIX_StreamAsgnReqType;
  SwigClassStreamAsgnReqType.trackObjects = 0;
  
  SwigClassBidSwapPoints.klass = rb_define_class_under(mQuickfix, "BidSwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidSwapPoints, (void *) &SwigClassBidSwapPoints);
  rb_define_alloc_func(SwigClassBidSwapPoints.klass, _wrap_BidSwapPoints_allocate);
  rb_define_method(SwigClassBidSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_BidSwapPoints), -1);
  SwigClassBidSwapPoints.mark = 0;
  SwigClassBidSwapPoints.destroy = (void (*)(void *)) free_FIX_BidSwapPoints;
  SwigClassBidSwapPoints.trackObjects = 0;
  
  SwigClassNoSettlPartyIDs.klass = rb_define_class_under(mQuickfix, "NoSettlPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlPartyIDs, (void *) &SwigClassNoSettlPartyIDs);
  rb_define_alloc_func(SwigClassNoSettlPartyIDs.klass, _wrap_NoSettlPartyIDs_allocate);
  rb_define_method(SwigClassNoSettlPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlPartyIDs), -1);
  SwigClassNoSettlPartyIDs.mark = 0;
  SwigClassNoSettlPartyIDs.destroy = (void (*)(void *)) free_FIX_NoSettlPartyIDs;
  SwigClassNoSettlPartyIDs.trackObjects = 0;
  
  SwigClassSymbolSfx.klass = rb_define_class_under(mQuickfix, "SymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SymbolSfx, (void *) &SwigClassSymbolSfx);
  rb_define_alloc_func(SwigClassSymbolSfx.klass, _wrap_SymbolSfx_allocate);
  rb_define_method(SwigClassSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_SymbolSfx), -1);
  SwigClassSymbolSfx.mark = 0;
  SwigClassSymbolSfx.destroy = (void (*)(void *)) free_FIX_SymbolSfx;
  SwigClassSymbolSfx.trackObjects = 0;
  
  SwigClassBusinessRejectRefID.klass = rb_define_class_under(mQuickfix, "BusinessRejectRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BusinessRejectRefID, (void *) &SwigClassBusinessRejectRefID);
  rb_define_alloc_func(SwigClassBusinessRejectRefID.klass, _wrap_BusinessRejectRefID_allocate);
  rb_define_method(SwigClassBusinessRejectRefID.klass, "initialize", VALUEFUNC(_wrap_new_BusinessRejectRefID), -1);
  SwigClassBusinessRejectRefID.mark = 0;
  SwigClassBusinessRejectRefID.destroy = (void (*)(void *)) free_FIX_BusinessRejectRefID;
  SwigClassBusinessRejectRefID.trackObjects = 0;
  
  SwigClassPrice2.klass = rb_define_class_under(mQuickfix, "Price2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Price2, (void *) &SwigClassPrice2);
  rb_define_alloc_func(SwigClassPrice2.klass, _wrap_Price2_allocate);
  rb_define_method(SwigClassPrice2.klass, "initialize", VALUEFUNC(_wrap_new_Price2), -1);
  SwigClassPrice2.mark = 0;
  SwigClassPrice2.destroy = (void (*)(void *)) free_FIX_Price2;
  SwigClassPrice2.trackObjects = 0;
  
  SwigClassFillLiquidityInd.klass = rb_define_class_under(mQuickfix, "FillLiquidityInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillLiquidityInd, (void *) &SwigClassFillLiquidityInd);
  rb_define_alloc_func(SwigClassFillLiquidityInd.klass, _wrap_FillLiquidityInd_allocate);
  rb_define_method(SwigClassFillLiquidityInd.klass, "initialize", VALUEFUNC(_wrap_new_FillLiquidityInd), -1);
  SwigClassFillLiquidityInd.mark = 0;
  SwigClassFillLiquidityInd.destroy = (void (*)(void *)) free_FIX_FillLiquidityInd;
  SwigClassFillLiquidityInd.trackObjects = 0;
  
  SwigClassMassActionReportID.klass = rb_define_class_under(mQuickfix, "MassActionReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionReportID, (void *) &SwigClassMassActionReportID);
  rb_define_alloc_func(SwigClassMassActionReportID.klass, _wrap_MassActionReportID_allocate);
  rb_define_method(SwigClassMassActionReportID.klass, "initialize", VALUEFUNC(_wrap_new_MassActionReportID), -1);
  SwigClassMassActionReportID.mark = 0;
  SwigClassMassActionReportID.destroy = (void (*)(void *)) free_FIX_MassActionReportID;
  SwigClassMassActionReportID.trackObjects = 0;
  
  SwigClassDerivativeIssuer.klass = rb_define_class_under(mQuickfix, "DerivativeIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeIssuer, (void *) &SwigClassDerivativeIssuer);
  rb_define_alloc_func(SwigClassDerivativeIssuer.klass, _wrap_DerivativeIssuer_allocate);
  rb_define_method(SwigClassDerivativeIssuer.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeIssuer), -1);
  SwigClassDerivativeIssuer.mark = 0;
  SwigClassDerivativeIssuer.destroy = (void (*)(void *)) free_FIX_DerivativeIssuer;
  SwigClassDerivativeIssuer.trackObjects = 0;
  
  SwigClassExDestinationIDSource.klass = rb_define_class_under(mQuickfix, "ExDestinationIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExDestinationIDSource, (void *) &SwigClassExDestinationIDSource);
  rb_define_alloc_func(SwigClassExDestinationIDSource.klass, _wrap_ExDestinationIDSource_allocate);
  rb_define_method(SwigClassExDestinationIDSource.klass, "initialize", VALUEFUNC(_wrap_new_ExDestinationIDSource), -1);
  SwigClassExDestinationIDSource.mark = 0;
  SwigClassExDestinationIDSource.destroy = (void (*)(void *)) free_FIX_ExDestinationIDSource;
  SwigClassExDestinationIDSource.trackObjects = 0;
  
  SwigClassCollRespID.klass = rb_define_class_under(mQuickfix, "CollRespID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollRespID, (void *) &SwigClassCollRespID);
  rb_define_alloc_func(SwigClassCollRespID.klass, _wrap_CollRespID_allocate);
  rb_define_method(SwigClassCollRespID.klass, "initialize", VALUEFUNC(_wrap_new_CollRespID), -1);
  SwigClassCollRespID.mark = 0;
  SwigClassCollRespID.destroy = (void (*)(void *)) free_FIX_CollRespID;
  SwigClassCollRespID.trackObjects = 0;
  
  SwigClassSecurityListRequestType.klass = rb_define_class_under(mQuickfix, "SecurityListRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListRequestType, (void *) &SwigClassSecurityListRequestType);
  rb_define_alloc_func(SwigClassSecurityListRequestType.klass, _wrap_SecurityListRequestType_allocate);
  rb_define_method(SwigClassSecurityListRequestType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListRequestType), -1);
  SwigClassSecurityListRequestType.mark = 0;
  SwigClassSecurityListRequestType.destroy = (void (*)(void *)) free_FIX_SecurityListRequestType;
  SwigClassSecurityListRequestType.trackObjects = 0;
  
  SwigClassEncodedLegSecurityDesc.klass = rb_define_class_under(mQuickfix, "EncodedLegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegSecurityDesc, (void *) &SwigClassEncodedLegSecurityDesc);
  rb_define_alloc_func(SwigClassEncodedLegSecurityDesc.klass, _wrap_EncodedLegSecurityDesc_allocate);
  rb_define_method(SwigClassEncodedLegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegSecurityDesc), -1);
  SwigClassEncodedLegSecurityDesc.mark = 0;
  SwigClassEncodedLegSecurityDesc.destroy = (void (*)(void *)) free_FIX_EncodedLegSecurityDesc;
  SwigClassEncodedLegSecurityDesc.trackObjects = 0;
  
  SwigClassUnderlyingSettlementStatus.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlementStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlementStatus, (void *) &SwigClassUnderlyingSettlementStatus);
  rb_define_alloc_func(SwigClassUnderlyingSettlementStatus.klass, _wrap_UnderlyingSettlementStatus_allocate);
  rb_define_method(SwigClassUnderlyingSettlementStatus.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlementStatus), -1);
  SwigClassUnderlyingSettlementStatus.mark = 0;
  SwigClassUnderlyingSettlementStatus.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlementStatus;
  SwigClassUnderlyingSettlementStatus.trackObjects = 0;
  
  SwigClassSecurityAltID.klass = rb_define_class_under(mQuickfix, "SecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityAltID, (void *) &SwigClassSecurityAltID);
  rb_define_alloc_func(SwigClassSecurityAltID.klass, _wrap_SecurityAltID_allocate);
  rb_define_method(SwigClassSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityAltID), -1);
  SwigClassSecurityAltID.mark = 0;
  SwigClassSecurityAltID.destroy = (void (*)(void *)) free_FIX_SecurityAltID;
  SwigClassSecurityAltID.trackObjects = 0;
  
  SwigClassRegistRefID.klass = rb_define_class_under(mQuickfix, "RegistRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistRefID, (void *) &SwigClassRegistRefID);
  rb_define_alloc_func(SwigClassRegistRefID.klass, _wrap_RegistRefID_allocate);
  rb_define_method(SwigClassRegistRefID.klass, "initialize", VALUEFUNC(_wrap_new_RegistRefID), -1);
  SwigClassRegistRefID.mark = 0;
  SwigClassRegistRefID.destroy = (void (*)(void *)) free_FIX_RegistRefID;
  SwigClassRegistRefID.trackObjects = 0;
  
  SwigClassDerivativePriceQuoteMethod.klass = rb_define_class_under(mQuickfix, "DerivativePriceQuoteMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePriceQuoteMethod, (void *) &SwigClassDerivativePriceQuoteMethod);
  rb_define_alloc_func(SwigClassDerivativePriceQuoteMethod.klass, _wrap_DerivativePriceQuoteMethod_allocate);
  rb_define_method(SwigClassDerivativePriceQuoteMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePriceQuoteMethod), -1);
  SwigClassDerivativePriceQuoteMethod.mark = 0;
  SwigClassDerivativePriceQuoteMethod.destroy = (void (*)(void *)) free_FIX_DerivativePriceQuoteMethod;
  SwigClassDerivativePriceQuoteMethod.trackObjects = 0;
  
  SwigClassOrderDelay.klass = rb_define_class_under(mQuickfix, "OrderDelay", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderDelay, (void *) &SwigClassOrderDelay);
  rb_define_alloc_func(SwigClassOrderDelay.klass, _wrap_OrderDelay_allocate);
  rb_define_method(SwigClassOrderDelay.klass, "initialize", VALUEFUNC(_wrap_new_OrderDelay), -1);
  SwigClassOrderDelay.mark = 0;
  SwigClassOrderDelay.destroy = (void (*)(void *)) free_FIX_OrderDelay;
  SwigClassOrderDelay.trackObjects = 0;
  
  SwigClassNoNotAffectedOrders.klass = rb_define_class_under(mQuickfix, "NoNotAffectedOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNotAffectedOrders, (void *) &SwigClassNoNotAffectedOrders);
  rb_define_alloc_func(SwigClassNoNotAffectedOrders.klass, _wrap_NoNotAffectedOrders_allocate);
  rb_define_method(SwigClassNoNotAffectedOrders.klass, "initialize", VALUEFUNC(_wrap_new_NoNotAffectedOrders), -1);
  SwigClassNoNotAffectedOrders.mark = 0;
  SwigClassNoNotAffectedOrders.destroy = (void (*)(void *)) free_FIX_NoNotAffectedOrders;
  SwigClassNoNotAffectedOrders.trackObjects = 0;
  
  SwigClassNested3PartyID.klass = rb_define_class_under(mQuickfix, "Nested3PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartyID, (void *) &SwigClassNested3PartyID);
  rb_define_alloc_func(SwigClassNested3PartyID.klass, _wrap_Nested3PartyID_allocate);
  rb_define_method(SwigClassNested3PartyID.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartyID), -1);
  SwigClassNested3PartyID.mark = 0;
  SwigClassNested3PartyID.destroy = (void (*)(void *)) free_FIX_Nested3PartyID;
  SwigClassNested3PartyID.trackObjects = 0;
  
  SwigClassCollAsgnReason.klass = rb_define_class_under(mQuickfix, "CollAsgnReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnReason, (void *) &SwigClassCollAsgnReason);
  rb_define_alloc_func(SwigClassCollAsgnReason.klass, _wrap_CollAsgnReason_allocate);
  rb_define_method(SwigClassCollAsgnReason.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnReason), -1);
  SwigClassCollAsgnReason.mark = 0;
  SwigClassCollAsgnReason.destroy = (void (*)(void *)) free_FIX_CollAsgnReason;
  SwigClassCollAsgnReason.trackObjects = 0;
  
  SwigClassTotalVolumeTradedTime.klass = rb_define_class_under(mQuickfix, "TotalVolumeTradedTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalVolumeTradedTime, (void *) &SwigClassTotalVolumeTradedTime);
  rb_define_alloc_func(SwigClassTotalVolumeTradedTime.klass, _wrap_TotalVolumeTradedTime_allocate);
  rb_define_method(SwigClassTotalVolumeTradedTime.klass, "initialize", VALUEFUNC(_wrap_new_TotalVolumeTradedTime), -1);
  SwigClassTotalVolumeTradedTime.mark = 0;
  SwigClassTotalVolumeTradedTime.destroy = (void (*)(void *)) free_FIX_TotalVolumeTradedTime;
  SwigClassTotalVolumeTradedTime.trackObjects = 0;
  
  SwigClassSecurityExchange.klass = rb_define_class_under(mQuickfix, "SecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityExchange, (void *) &SwigClassSecurityExchange);
  rb_define_alloc_func(SwigClassSecurityExchange.klass, _wrap_SecurityExchange_allocate);
  rb_define_method(SwigClassSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_SecurityExchange), -1);
  SwigClassSecurityExchange.mark = 0;
  SwigClassSecurityExchange.destroy = (void (*)(void *)) free_FIX_SecurityExchange;
  SwigClassSecurityExchange.trackObjects = 0;
  
  SwigClassSettlPriceType.klass = rb_define_class_under(mQuickfix, "SettlPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPriceType, (void *) &SwigClassSettlPriceType);
  rb_define_alloc_func(SwigClassSettlPriceType.klass, _wrap_SettlPriceType_allocate);
  rb_define_method(SwigClassSettlPriceType.klass, "initialize", VALUEFUNC(_wrap_new_SettlPriceType), -1);
  SwigClassSettlPriceType.mark = 0;
  SwigClassSettlPriceType.destroy = (void (*)(void *)) free_FIX_SettlPriceType;
  SwigClassSettlPriceType.trackObjects = 0;
  
  SwigClassUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "UnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnitOfMeasureQty, (void *) &SwigClassUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassUnitOfMeasureQty.klass, _wrap_UnitOfMeasureQty_allocate);
  rb_define_method(SwigClassUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_UnitOfMeasureQty), -1);
  SwigClassUnitOfMeasureQty.mark = 0;
  SwigClassUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_UnitOfMeasureQty;
  SwigClassUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassUserRequestID.klass = rb_define_class_under(mQuickfix, "UserRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserRequestID, (void *) &SwigClassUserRequestID);
  rb_define_alloc_func(SwigClassUserRequestID.klass, _wrap_UserRequestID_allocate);
  rb_define_method(SwigClassUserRequestID.klass, "initialize", VALUEFUNC(_wrap_new_UserRequestID), -1);
  SwigClassUserRequestID.mark = 0;
  SwigClassUserRequestID.destroy = (void (*)(void *)) free_FIX_UserRequestID;
  SwigClassUserRequestID.trackObjects = 0;
  
  SwigClassLastParPx.klass = rb_define_class_under(mQuickfix, "LastParPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastParPx, (void *) &SwigClassLastParPx);
  rb_define_alloc_func(SwigClassLastParPx.klass, _wrap_LastParPx_allocate);
  rb_define_method(SwigClassLastParPx.klass, "initialize", VALUEFUNC(_wrap_new_LastParPx), -1);
  SwigClassLastParPx.mark = 0;
  SwigClassLastParPx.destroy = (void (*)(void *)) free_FIX_LastParPx;
  SwigClassLastParPx.trackObjects = 0;
  
  SwigClassEndMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "EndMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndMaturityMonthYear, (void *) &SwigClassEndMaturityMonthYear);
  rb_define_alloc_func(SwigClassEndMaturityMonthYear.klass, _wrap_EndMaturityMonthYear_allocate);
  rb_define_method(SwigClassEndMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_EndMaturityMonthYear), -1);
  SwigClassEndMaturityMonthYear.mark = 0;
  SwigClassEndMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_EndMaturityMonthYear;
  SwigClassEndMaturityMonthYear.trackObjects = 0;
  
  SwigClassDealingCapacity.klass = rb_define_class_under(mQuickfix, "DealingCapacity", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DealingCapacity, (void *) &SwigClassDealingCapacity);
  rb_define_alloc_func(SwigClassDealingCapacity.klass, _wrap_DealingCapacity_allocate);
  rb_define_method(SwigClassDealingCapacity.klass, "initialize", VALUEFUNC(_wrap_new_DealingCapacity), -1);
  SwigClassDealingCapacity.mark = 0;
  SwigClassDealingCapacity.destroy = (void (*)(void *)) free_FIX_DealingCapacity;
  SwigClassDealingCapacity.trackObjects = 0;
  
  SwigClassPrevClosePx.klass = rb_define_class_under(mQuickfix, "PrevClosePx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PrevClosePx, (void *) &SwigClassPrevClosePx);
  rb_define_alloc_func(SwigClassPrevClosePx.klass, _wrap_PrevClosePx_allocate);
  rb_define_method(SwigClassPrevClosePx.klass, "initialize", VALUEFUNC(_wrap_new_PrevClosePx), -1);
  SwigClassPrevClosePx.mark = 0;
  SwigClassPrevClosePx.destroy = (void (*)(void *)) free_FIX_PrevClosePx;
  SwigClassPrevClosePx.trackObjects = 0;
  
  SwigClassTradeInputDevice.klass = rb_define_class_under(mQuickfix, "TradeInputDevice", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeInputDevice, (void *) &SwigClassTradeInputDevice);
  rb_define_alloc_func(SwigClassTradeInputDevice.klass, _wrap_TradeInputDevice_allocate);
  rb_define_method(SwigClassTradeInputDevice.klass, "initialize", VALUEFUNC(_wrap_new_TradeInputDevice), -1);
  SwigClassTradeInputDevice.mark = 0;
  SwigClassTradeInputDevice.destroy = (void (*)(void *)) free_FIX_TradeInputDevice;
  SwigClassTradeInputDevice.trackObjects = 0;
  
  SwigClassDayCumQty.klass = rb_define_class_under(mQuickfix, "DayCumQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayCumQty, (void *) &SwigClassDayCumQty);
  rb_define_alloc_func(SwigClassDayCumQty.klass, _wrap_DayCumQty_allocate);
  rb_define_method(SwigClassDayCumQty.klass, "initialize", VALUEFUNC(_wrap_new_DayCumQty), -1);
  SwigClassDayCumQty.mark = 0;
  SwigClassDayCumQty.destroy = (void (*)(void *)) free_FIX_DayCumQty;
  SwigClassDayCumQty.trackObjects = 0;
  
  SwigClassSecuritySettlAgentAcctNum.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentAcctNum", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum, (void *) &SwigClassSecuritySettlAgentAcctNum);
  rb_define_alloc_func(SwigClassSecuritySettlAgentAcctNum.klass, _wrap_SecuritySettlAgentAcctNum_allocate);
  rb_define_method(SwigClassSecuritySettlAgentAcctNum.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentAcctNum), -1);
  SwigClassSecuritySettlAgentAcctNum.mark = 0;
  SwigClassSecuritySettlAgentAcctNum.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentAcctNum;
  SwigClassSecuritySettlAgentAcctNum.trackObjects = 0;
  
  SwigClassLegCurrency.klass = rb_define_class_under(mQuickfix, "LegCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCurrency, (void *) &SwigClassLegCurrency);
  rb_define_alloc_func(SwigClassLegCurrency.klass, _wrap_LegCurrency_allocate);
  rb_define_method(SwigClassLegCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegCurrency), -1);
  SwigClassLegCurrency.mark = 0;
  SwigClassLegCurrency.destroy = (void (*)(void *)) free_FIX_LegCurrency;
  SwigClassLegCurrency.trackObjects = 0;
  
  SwigClassEncryptedNewPassword.klass = rb_define_class_under(mQuickfix, "EncryptedNewPassword", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedNewPassword, (void *) &SwigClassEncryptedNewPassword);
  rb_define_alloc_func(SwigClassEncryptedNewPassword.klass, _wrap_EncryptedNewPassword_allocate);
  rb_define_method(SwigClassEncryptedNewPassword.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedNewPassword), -1);
  SwigClassEncryptedNewPassword.mark = 0;
  SwigClassEncryptedNewPassword.destroy = (void (*)(void *)) free_FIX_EncryptedNewPassword;
  SwigClassEncryptedNewPassword.trackObjects = 0;
  
  SwigClassDerivativeMinPriceIncrementAmount.klass = rb_define_class_under(mQuickfix, "DerivativeMinPriceIncrementAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount, (void *) &SwigClassDerivativeMinPriceIncrementAmount);
  rb_define_alloc_func(SwigClassDerivativeMinPriceIncrementAmount.klass, _wrap_DerivativeMinPriceIncrementAmount_allocate);
  rb_define_method(SwigClassDerivativeMinPriceIncrementAmount.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMinPriceIncrementAmount), -1);
  SwigClassDerivativeMinPriceIncrementAmount.mark = 0;
  SwigClassDerivativeMinPriceIncrementAmount.destroy = (void (*)(void *)) free_FIX_DerivativeMinPriceIncrementAmount;
  SwigClassDerivativeMinPriceIncrementAmount.trackObjects = 0;
  
  SwigClassNoNested3PartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNested3PartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested3PartySubIDs, (void *) &SwigClassNoNested3PartySubIDs);
  rb_define_alloc_func(SwigClassNoNested3PartySubIDs.klass, _wrap_NoNested3PartySubIDs_allocate);
  rb_define_method(SwigClassNoNested3PartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested3PartySubIDs), -1);
  SwigClassNoNested3PartySubIDs.mark = 0;
  SwigClassNoNested3PartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNested3PartySubIDs;
  SwigClassNoNested3PartySubIDs.trackObjects = 0;
  
  SwigClassRefSubID.klass = rb_define_class_under(mQuickfix, "RefSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefSubID, (void *) &SwigClassRefSubID);
  rb_define_alloc_func(SwigClassRefSubID.klass, _wrap_RefSubID_allocate);
  rb_define_method(SwigClassRefSubID.klass, "initialize", VALUEFUNC(_wrap_new_RefSubID), -1);
  SwigClassRefSubID.mark = 0;
  SwigClassRefSubID.destroy = (void (*)(void *)) free_FIX_RefSubID;
  SwigClassRefSubID.trackObjects = 0;
  
  SwigClassSettlPartyRole.klass = rb_define_class_under(mQuickfix, "SettlPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartyRole, (void *) &SwigClassSettlPartyRole);
  rb_define_alloc_func(SwigClassSettlPartyRole.klass, _wrap_SettlPartyRole_allocate);
  rb_define_method(SwigClassSettlPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartyRole), -1);
  SwigClassSettlPartyRole.mark = 0;
  SwigClassSettlPartyRole.destroy = (void (*)(void *)) free_FIX_SettlPartyRole;
  SwigClassSettlPartyRole.trackObjects = 0;
  
  SwigClassCashDistribAgentName.klass = rb_define_class_under(mQuickfix, "CashDistribAgentName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentName, (void *) &SwigClassCashDistribAgentName);
  rb_define_alloc_func(SwigClassCashDistribAgentName.klass, _wrap_CashDistribAgentName_allocate);
  rb_define_method(SwigClassCashDistribAgentName.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentName), -1);
  SwigClassCashDistribAgentName.mark = 0;
  SwigClassCashDistribAgentName.destroy = (void (*)(void *)) free_FIX_CashDistribAgentName;
  SwigClassCashDistribAgentName.trackObjects = 0;
  
  SwigClassLegContractMultiplier.klass = rb_define_class_under(mQuickfix, "LegContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegContractMultiplier, (void *) &SwigClassLegContractMultiplier);
  rb_define_alloc_func(SwigClassLegContractMultiplier.klass, _wrap_LegContractMultiplier_allocate);
  rb_define_method(SwigClassLegContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_LegContractMultiplier), -1);
  SwigClassLegContractMultiplier.mark = 0;
  SwigClassLegContractMultiplier.destroy = (void (*)(void *)) free_FIX_LegContractMultiplier;
  SwigClassLegContractMultiplier.trackObjects = 0;
  
  SwigClassProgPeriodInterval.klass = rb_define_class_under(mQuickfix, "ProgPeriodInterval", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProgPeriodInterval, (void *) &SwigClassProgPeriodInterval);
  rb_define_alloc_func(SwigClassProgPeriodInterval.klass, _wrap_ProgPeriodInterval_allocate);
  rb_define_method(SwigClassProgPeriodInterval.klass, "initialize", VALUEFUNC(_wrap_new_ProgPeriodInterval), -1);
  SwigClassProgPeriodInterval.mark = 0;
  SwigClassProgPeriodInterval.destroy = (void (*)(void *)) free_FIX_ProgPeriodInterval;
  SwigClassProgPeriodInterval.trackObjects = 0;
  
  SwigClassLegSettlType.klass = rb_define_class_under(mQuickfix, "LegSettlType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlType, (void *) &SwigClassLegSettlType);
  rb_define_alloc_func(SwigClassLegSettlType.klass, _wrap_LegSettlType_allocate);
  rb_define_method(SwigClassLegSettlType.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlType), -1);
  SwigClassLegSettlType.mark = 0;
  SwigClassLegSettlType.destroy = (void (*)(void *)) free_FIX_LegSettlType;
  SwigClassLegSettlType.trackObjects = 0;
  
  SwigClassOnBehalfOfLocationID.klass = rb_define_class_under(mQuickfix, "OnBehalfOfLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfLocationID, (void *) &SwigClassOnBehalfOfLocationID);
  rb_define_alloc_func(SwigClassOnBehalfOfLocationID.klass, _wrap_OnBehalfOfLocationID_allocate);
  rb_define_method(SwigClassOnBehalfOfLocationID.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfLocationID), -1);
  SwigClassOnBehalfOfLocationID.mark = 0;
  SwigClassOnBehalfOfLocationID.destroy = (void (*)(void *)) free_FIX_OnBehalfOfLocationID;
  SwigClassOnBehalfOfLocationID.trackObjects = 0;
  
  SwigClassOnBehalfOfSubID.klass = rb_define_class_under(mQuickfix, "OnBehalfOfSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfSubID, (void *) &SwigClassOnBehalfOfSubID);
  rb_define_alloc_func(SwigClassOnBehalfOfSubID.klass, _wrap_OnBehalfOfSubID_allocate);
  rb_define_method(SwigClassOnBehalfOfSubID.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfSubID), -1);
  SwigClassOnBehalfOfSubID.mark = 0;
  SwigClassOnBehalfOfSubID.destroy = (void (*)(void *)) free_FIX_OnBehalfOfSubID;
  SwigClassOnBehalfOfSubID.trackObjects = 0;
  
  SwigClassComplexEventEndTime.klass = rb_define_class_under(mQuickfix, "ComplexEventEndTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventEndTime, (void *) &SwigClassComplexEventEndTime);
  rb_define_alloc_func(SwigClassComplexEventEndTime.klass, _wrap_ComplexEventEndTime_allocate);
  rb_define_method(SwigClassComplexEventEndTime.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventEndTime), -1);
  SwigClassComplexEventEndTime.mark = 0;
  SwigClassComplexEventEndTime.destroy = (void (*)(void *)) free_FIX_ComplexEventEndTime;
  SwigClassComplexEventEndTime.trackObjects = 0;
  
  SwigClassRateSourceType.klass = rb_define_class_under(mQuickfix, "RateSourceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RateSourceType, (void *) &SwigClassRateSourceType);
  rb_define_alloc_func(SwigClassRateSourceType.klass, _wrap_RateSourceType_allocate);
  rb_define_method(SwigClassRateSourceType.klass, "initialize", VALUEFUNC(_wrap_new_RateSourceType), -1);
  SwigClassRateSourceType.mark = 0;
  SwigClassRateSourceType.destroy = (void (*)(void *)) free_FIX_RateSourceType;
  SwigClassRateSourceType.trackObjects = 0;
  
  SwigClassDerivativeStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "DerivativeStateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue, (void *) &SwigClassDerivativeStateOrProvinceOfIssue);
  rb_define_alloc_func(SwigClassDerivativeStateOrProvinceOfIssue.klass, _wrap_DerivativeStateOrProvinceOfIssue_allocate);
  rb_define_method(SwigClassDerivativeStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStateOrProvinceOfIssue), -1);
  SwigClassDerivativeStateOrProvinceOfIssue.mark = 0;
  SwigClassDerivativeStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_DerivativeStateOrProvinceOfIssue;
  SwigClassDerivativeStateOrProvinceOfIssue.trackObjects = 0;
  
  SwigClassTradeLegRefID.klass = rb_define_class_under(mQuickfix, "TradeLegRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeLegRefID, (void *) &SwigClassTradeLegRefID);
  rb_define_alloc_func(SwigClassTradeLegRefID.klass, _wrap_TradeLegRefID_allocate);
  rb_define_method(SwigClassTradeLegRefID.klass, "initialize", VALUEFUNC(_wrap_new_TradeLegRefID), -1);
  SwigClassTradeLegRefID.mark = 0;
  SwigClassTradeLegRefID.destroy = (void (*)(void *)) free_FIX_TradeLegRefID;
  SwigClassTradeLegRefID.trackObjects = 0;
  
  SwigClassRelSymTransactTime.klass = rb_define_class_under(mQuickfix, "RelSymTransactTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelSymTransactTime, (void *) &SwigClassRelSymTransactTime);
  rb_define_alloc_func(SwigClassRelSymTransactTime.klass, _wrap_RelSymTransactTime_allocate);
  rb_define_method(SwigClassRelSymTransactTime.klass, "initialize", VALUEFUNC(_wrap_new_RelSymTransactTime), -1);
  SwigClassRelSymTransactTime.mark = 0;
  SwigClassRelSymTransactTime.destroy = (void (*)(void *)) free_FIX_RelSymTransactTime;
  SwigClassRelSymTransactTime.trackObjects = 0;
  
  SwigClassNoComplexEventTimes.klass = rb_define_class_under(mQuickfix, "NoComplexEventTimes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoComplexEventTimes, (void *) &SwigClassNoComplexEventTimes);
  rb_define_alloc_func(SwigClassNoComplexEventTimes.klass, _wrap_NoComplexEventTimes_allocate);
  rb_define_method(SwigClassNoComplexEventTimes.klass, "initialize", VALUEFUNC(_wrap_new_NoComplexEventTimes), -1);
  SwigClassNoComplexEventTimes.mark = 0;
  SwigClassNoComplexEventTimes.destroy = (void (*)(void *)) free_FIX_NoComplexEventTimes;
  SwigClassNoComplexEventTimes.trackObjects = 0;
  
  SwigClassLegCalculatedCcyLastQty.klass = rb_define_class_under(mQuickfix, "LegCalculatedCcyLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCalculatedCcyLastQty, (void *) &SwigClassLegCalculatedCcyLastQty);
  rb_define_alloc_func(SwigClassLegCalculatedCcyLastQty.klass, _wrap_LegCalculatedCcyLastQty_allocate);
  rb_define_method(SwigClassLegCalculatedCcyLastQty.klass, "initialize", VALUEFUNC(_wrap_new_LegCalculatedCcyLastQty), -1);
  SwigClassLegCalculatedCcyLastQty.mark = 0;
  SwigClassLegCalculatedCcyLastQty.destroy = (void (*)(void *)) free_FIX_LegCalculatedCcyLastQty;
  SwigClassLegCalculatedCcyLastQty.trackObjects = 0;
  
  SwigClassNested3PartyIDSource.klass = rb_define_class_under(mQuickfix, "Nested3PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartyIDSource, (void *) &SwigClassNested3PartyIDSource);
  rb_define_alloc_func(SwigClassNested3PartyIDSource.klass, _wrap_Nested3PartyIDSource_allocate);
  rb_define_method(SwigClassNested3PartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartyIDSource), -1);
  SwigClassNested3PartyIDSource.mark = 0;
  SwigClassNested3PartyIDSource.destroy = (void (*)(void *)) free_FIX_Nested3PartyIDSource;
  SwigClassNested3PartyIDSource.trackObjects = 0;
  
  SwigClassDatedDate.klass = rb_define_class_under(mQuickfix, "DatedDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DatedDate, (void *) &SwigClassDatedDate);
  rb_define_alloc_func(SwigClassDatedDate.klass, _wrap_DatedDate_allocate);
  rb_define_method(SwigClassDatedDate.klass, "initialize", VALUEFUNC(_wrap_new_DatedDate), -1);
  SwigClassDatedDate.mark = 0;
  SwigClassDatedDate.destroy = (void (*)(void *)) free_FIX_DatedDate;
  SwigClassDatedDate.trackObjects = 0;
  
  SwigClassSettlInstID.klass = rb_define_class_under(mQuickfix, "SettlInstID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstID, (void *) &SwigClassSettlInstID);
  rb_define_alloc_func(SwigClassSettlInstID.klass, _wrap_SettlInstID_allocate);
  rb_define_method(SwigClassSettlInstID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstID), -1);
  SwigClassSettlInstID.mark = 0;
  SwigClassSettlInstID.destroy = (void (*)(void *)) free_FIX_SettlInstID;
  SwigClassSettlInstID.trackObjects = 0;
  
  SwigClassOpenInterest.klass = rb_define_class_under(mQuickfix, "OpenInterest", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenInterest, (void *) &SwigClassOpenInterest);
  rb_define_alloc_func(SwigClassOpenInterest.klass, _wrap_OpenInterest_allocate);
  rb_define_method(SwigClassOpenInterest.klass, "initialize", VALUEFUNC(_wrap_new_OpenInterest), -1);
  SwigClassOpenInterest.mark = 0;
  SwigClassOpenInterest.destroy = (void (*)(void *)) free_FIX_OpenInterest;
  SwigClassOpenInterest.trackObjects = 0;
  
  SwigClassUnderlyingContractMultiplier.klass = rb_define_class_under(mQuickfix, "UnderlyingContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingContractMultiplier, (void *) &SwigClassUnderlyingContractMultiplier);
  rb_define_alloc_func(SwigClassUnderlyingContractMultiplier.klass, _wrap_UnderlyingContractMultiplier_allocate);
  rb_define_method(SwigClassUnderlyingContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingContractMultiplier), -1);
  SwigClassUnderlyingContractMultiplier.mark = 0;
  SwigClassUnderlyingContractMultiplier.destroy = (void (*)(void *)) free_FIX_UnderlyingContractMultiplier;
  SwigClassUnderlyingContractMultiplier.trackObjects = 0;
  
  SwigClassTotQuoteEntries.klass = rb_define_class_under(mQuickfix, "TotQuoteEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotQuoteEntries, (void *) &SwigClassTotQuoteEntries);
  rb_define_alloc_func(SwigClassTotQuoteEntries.klass, _wrap_TotQuoteEntries_allocate);
  rb_define_method(SwigClassTotQuoteEntries.klass, "initialize", VALUEFUNC(_wrap_new_TotQuoteEntries), -1);
  SwigClassTotQuoteEntries.mark = 0;
  SwigClassTotQuoteEntries.destroy = (void (*)(void *)) free_FIX_TotQuoteEntries;
  SwigClassTotQuoteEntries.trackObjects = 0;
  
  SwigClassTotNoCxldQuotes.klass = rb_define_class_under(mQuickfix, "TotNoCxldQuotes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoCxldQuotes, (void *) &SwigClassTotNoCxldQuotes);
  rb_define_alloc_func(SwigClassTotNoCxldQuotes.klass, _wrap_TotNoCxldQuotes_allocate);
  rb_define_method(SwigClassTotNoCxldQuotes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoCxldQuotes), -1);
  SwigClassTotNoCxldQuotes.mark = 0;
  SwigClassTotNoCxldQuotes.destroy = (void (*)(void *)) free_FIX_TotNoCxldQuotes;
  SwigClassTotNoCxldQuotes.trackObjects = 0;
  
  SwigClassAggregatedBook.klass = rb_define_class_under(mQuickfix, "AggregatedBook", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AggregatedBook, (void *) &SwigClassAggregatedBook);
  rb_define_alloc_func(SwigClassAggregatedBook.klass, _wrap_AggregatedBook_allocate);
  rb_define_method(SwigClassAggregatedBook.klass, "initialize", VALUEFUNC(_wrap_new_AggregatedBook), -1);
  SwigClassAggregatedBook.mark = 0;
  SwigClassAggregatedBook.destroy = (void (*)(void *)) free_FIX_AggregatedBook;
  SwigClassAggregatedBook.trackObjects = 0;
  
  SwigClassPaymentRef.klass = rb_define_class_under(mQuickfix, "PaymentRef", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentRef, (void *) &SwigClassPaymentRef);
  rb_define_alloc_func(SwigClassPaymentRef.klass, _wrap_PaymentRef_allocate);
  rb_define_method(SwigClassPaymentRef.klass, "initialize", VALUEFUNC(_wrap_new_PaymentRef), -1);
  SwigClassPaymentRef.mark = 0;
  SwigClassPaymentRef.destroy = (void (*)(void *)) free_FIX_PaymentRef;
  SwigClassPaymentRef.trackObjects = 0;
  
  SwigClassPaymentDate.klass = rb_define_class_under(mQuickfix, "PaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentDate, (void *) &SwigClassPaymentDate);
  rb_define_alloc_func(SwigClassPaymentDate.klass, _wrap_PaymentDate_allocate);
  rb_define_method(SwigClassPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_PaymentDate), -1);
  SwigClassPaymentDate.mark = 0;
  SwigClassPaymentDate.destroy = (void (*)(void *)) free_FIX_PaymentDate;
  SwigClassPaymentDate.trackObjects = 0;
  
  SwigClassOrderPercent.klass = rb_define_class_under(mQuickfix, "OrderPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderPercent, (void *) &SwigClassOrderPercent);
  rb_define_alloc_func(SwigClassOrderPercent.klass, _wrap_OrderPercent_allocate);
  rb_define_method(SwigClassOrderPercent.klass, "initialize", VALUEFUNC(_wrap_new_OrderPercent), -1);
  SwigClassOrderPercent.mark = 0;
  SwigClassOrderPercent.destroy = (void (*)(void *)) free_FIX_OrderPercent;
  SwigClassOrderPercent.trackObjects = 0;
  
  SwigClassPosQtyStatus.klass = rb_define_class_under(mQuickfix, "PosQtyStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosQtyStatus, (void *) &SwigClassPosQtyStatus);
  rb_define_alloc_func(SwigClassPosQtyStatus.klass, _wrap_PosQtyStatus_allocate);
  rb_define_method(SwigClassPosQtyStatus.klass, "initialize", VALUEFUNC(_wrap_new_PosQtyStatus), -1);
  SwigClassPosQtyStatus.mark = 0;
  SwigClassPosQtyStatus.destroy = (void (*)(void *)) free_FIX_PosQtyStatus;
  SwigClassPosQtyStatus.trackObjects = 0;
  
  SwigClassNoNested4PartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNested4PartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested4PartySubIDs, (void *) &SwigClassNoNested4PartySubIDs);
  rb_define_alloc_func(SwigClassNoNested4PartySubIDs.klass, _wrap_NoNested4PartySubIDs_allocate);
  rb_define_method(SwigClassNoNested4PartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested4PartySubIDs), -1);
  SwigClassNoNested4PartySubIDs.mark = 0;
  SwigClassNoNested4PartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNested4PartySubIDs;
  SwigClassNoNested4PartySubIDs.trackObjects = 0;
  
  SwigClassPrivateQuote.klass = rb_define_class_under(mQuickfix, "PrivateQuote", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PrivateQuote, (void *) &SwigClassPrivateQuote);
  rb_define_alloc_func(SwigClassPrivateQuote.klass, _wrap_PrivateQuote_allocate);
  rb_define_method(SwigClassPrivateQuote.klass, "initialize", VALUEFUNC(_wrap_new_PrivateQuote), -1);
  SwigClassPrivateQuote.mark = 0;
  SwigClassPrivateQuote.destroy = (void (*)(void *)) free_FIX_PrivateQuote;
  SwigClassPrivateQuote.trackObjects = 0;
  
  SwigClassSecondaryTradeID.klass = rb_define_class_under(mQuickfix, "SecondaryTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradeID, (void *) &SwigClassSecondaryTradeID);
  rb_define_alloc_func(SwigClassSecondaryTradeID.klass, _wrap_SecondaryTradeID_allocate);
  rb_define_method(SwigClassSecondaryTradeID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradeID), -1);
  SwigClassSecondaryTradeID.mark = 0;
  SwigClassSecondaryTradeID.destroy = (void (*)(void *)) free_FIX_SecondaryTradeID;
  SwigClassSecondaryTradeID.trackObjects = 0;
  
  SwigClassSecuritySettlAgentContactPhone.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentContactPhone", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone, (void *) &SwigClassSecuritySettlAgentContactPhone);
  rb_define_alloc_func(SwigClassSecuritySettlAgentContactPhone.klass, _wrap_SecuritySettlAgentContactPhone_allocate);
  rb_define_method(SwigClassSecuritySettlAgentContactPhone.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentContactPhone), -1);
  SwigClassSecuritySettlAgentContactPhone.mark = 0;
  SwigClassSecuritySettlAgentContactPhone.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentContactPhone;
  SwigClassSecuritySettlAgentContactPhone.trackObjects = 0;
  
  SwigClassEncodedMktSegmDescLen.klass = rb_define_class_under(mQuickfix, "EncodedMktSegmDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedMktSegmDescLen, (void *) &SwigClassEncodedMktSegmDescLen);
  rb_define_alloc_func(SwigClassEncodedMktSegmDescLen.klass, _wrap_EncodedMktSegmDescLen_allocate);
  rb_define_method(SwigClassEncodedMktSegmDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedMktSegmDescLen), -1);
  SwigClassEncodedMktSegmDescLen.mark = 0;
  SwigClassEncodedMktSegmDescLen.destroy = (void (*)(void *)) free_FIX_EncodedMktSegmDescLen;
  SwigClassEncodedMktSegmDescLen.trackObjects = 0;
  
  SwigClassSideCurrency.klass = rb_define_class_under(mQuickfix, "SideCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideCurrency, (void *) &SwigClassSideCurrency);
  rb_define_alloc_func(SwigClassSideCurrency.klass, _wrap_SideCurrency_allocate);
  rb_define_method(SwigClassSideCurrency.klass, "initialize", VALUEFUNC(_wrap_new_SideCurrency), -1);
  SwigClassSideCurrency.mark = 0;
  SwigClassSideCurrency.destroy = (void (*)(void *)) free_FIX_SideCurrency;
  SwigClassSideCurrency.trackObjects = 0;
  
  SwigClassLegQty.klass = rb_define_class_under(mQuickfix, "LegQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegQty, (void *) &SwigClassLegQty);
  rb_define_alloc_func(SwigClassLegQty.klass, _wrap_LegQty_allocate);
  rb_define_method(SwigClassLegQty.klass, "initialize", VALUEFUNC(_wrap_new_LegQty), -1);
  SwigClassLegQty.mark = 0;
  SwigClassLegQty.destroy = (void (*)(void *)) free_FIX_LegQty;
  SwigClassLegQty.trackObjects = 0;
  
  SwigClassMsgType.klass = rb_define_class_under(mQuickfix, "MsgType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MsgType, (void *) &SwigClassMsgType);
  rb_define_alloc_func(SwigClassMsgType.klass, _wrap_MsgType_allocate);
  rb_define_method(SwigClassMsgType.klass, "initialize", VALUEFUNC(_wrap_new_MsgType), -1);
  SwigClassMsgType.mark = 0;
  SwigClassMsgType.destroy = (void (*)(void *)) free_FIX_MsgType;
  SwigClassMsgType.trackObjects = 0;
  
  SwigClassNoTradingSessions.klass = rb_define_class_under(mQuickfix, "NoTradingSessions", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTradingSessions, (void *) &SwigClassNoTradingSessions);
  rb_define_alloc_func(SwigClassNoTradingSessions.klass, _wrap_NoTradingSessions_allocate);
  rb_define_method(SwigClassNoTradingSessions.klass, "initialize", VALUEFUNC(_wrap_new_NoTradingSessions), -1);
  SwigClassNoTradingSessions.mark = 0;
  SwigClassNoTradingSessions.destroy = (void (*)(void *)) free_FIX_NoTradingSessions;
  SwigClassNoTradingSessions.trackObjects = 0;
  
  SwigClassIOIid.klass = rb_define_class_under(mQuickfix, "IOIid", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIid, (void *) &SwigClassIOIid);
  rb_define_alloc_func(SwigClassIOIid.klass, _wrap_IOIid_allocate);
  rb_define_method(SwigClassIOIid.klass, "initialize", VALUEFUNC(_wrap_new_IOIid), -1);
  SwigClassIOIid.mark = 0;
  SwigClassIOIid.destroy = (void (*)(void *)) free_FIX_IOIid;
  SwigClassIOIid.trackObjects = 0;
  
  SwigClassMultiLegReportingType.klass = rb_define_class_under(mQuickfix, "MultiLegReportingType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultiLegReportingType, (void *) &SwigClassMultiLegReportingType);
  rb_define_alloc_func(SwigClassMultiLegReportingType.klass, _wrap_MultiLegReportingType_allocate);
  rb_define_method(SwigClassMultiLegReportingType.klass, "initialize", VALUEFUNC(_wrap_new_MultiLegReportingType), -1);
  SwigClassMultiLegReportingType.mark = 0;
  SwigClassMultiLegReportingType.destroy = (void (*)(void *)) free_FIX_MultiLegReportingType;
  SwigClassMultiLegReportingType.trackObjects = 0;
  
  SwigClassIDSource.klass = rb_define_class_under(mQuickfix, "IDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IDSource, (void *) &SwigClassIDSource);
  rb_define_alloc_func(SwigClassIDSource.klass, _wrap_IDSource_allocate);
  rb_define_method(SwigClassIDSource.klass, "initialize", VALUEFUNC(_wrap_new_IDSource), -1);
  SwigClassIDSource.mark = 0;
  SwigClassIDSource.destroy = (void (*)(void *)) free_FIX_IDSource;
  SwigClassIDSource.trackObjects = 0;
  
  SwigClassLegStipulationType.klass = rb_define_class_under(mQuickfix, "LegStipulationType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStipulationType, (void *) &SwigClassLegStipulationType);
  rb_define_alloc_func(SwigClassLegStipulationType.klass, _wrap_LegStipulationType_allocate);
  rb_define_method(SwigClassLegStipulationType.klass, "initialize", VALUEFUNC(_wrap_new_LegStipulationType), -1);
  SwigClassLegStipulationType.mark = 0;
  SwigClassLegStipulationType.destroy = (void (*)(void *)) free_FIX_LegStipulationType;
  SwigClassLegStipulationType.trackObjects = 0;
  
  SwigClassDerivativeContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "DerivativeContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit, (void *) &SwigClassDerivativeContractMultiplierUnit);
  rb_define_alloc_func(SwigClassDerivativeContractMultiplierUnit.klass, _wrap_DerivativeContractMultiplierUnit_allocate);
  rb_define_method(SwigClassDerivativeContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeContractMultiplierUnit), -1);
  SwigClassDerivativeContractMultiplierUnit.mark = 0;
  SwigClassDerivativeContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_DerivativeContractMultiplierUnit;
  SwigClassDerivativeContractMultiplierUnit.trackObjects = 0;
  
  SwigClassMarketSegmentID.klass = rb_define_class_under(mQuickfix, "MarketSegmentID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketSegmentID, (void *) &SwigClassMarketSegmentID);
  rb_define_alloc_func(SwigClassMarketSegmentID.klass, _wrap_MarketSegmentID_allocate);
  rb_define_method(SwigClassMarketSegmentID.klass, "initialize", VALUEFUNC(_wrap_new_MarketSegmentID), -1);
  SwigClassMarketSegmentID.mark = 0;
  SwigClassMarketSegmentID.destroy = (void (*)(void *)) free_FIX_MarketSegmentID;
  SwigClassMarketSegmentID.trackObjects = 0;
  
  SwigClassOrdStatus.klass = rb_define_class_under(mQuickfix, "OrdStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdStatus, (void *) &SwigClassOrdStatus);
  rb_define_alloc_func(SwigClassOrdStatus.klass, _wrap_OrdStatus_allocate);
  rb_define_method(SwigClassOrdStatus.klass, "initialize", VALUEFUNC(_wrap_new_OrdStatus), -1);
  SwigClassOrdStatus.mark = 0;
  SwigClassOrdStatus.destroy = (void (*)(void *)) free_FIX_OrdStatus;
  SwigClassOrdStatus.trackObjects = 0;
  
  SwigClassMaturityDate.klass = rb_define_class_under(mQuickfix, "MaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityDate, (void *) &SwigClassMaturityDate);
  rb_define_alloc_func(SwigClassMaturityDate.klass, _wrap_MaturityDate_allocate);
  rb_define_method(SwigClassMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_MaturityDate), -1);
  SwigClassMaturityDate.mark = 0;
  SwigClassMaturityDate.destroy = (void (*)(void *)) free_FIX_MaturityDate;
  SwigClassMaturityDate.trackObjects = 0;
  
  SwigClassApplTotalMessageCount.klass = rb_define_class_under(mQuickfix, "ApplTotalMessageCount", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplTotalMessageCount, (void *) &SwigClassApplTotalMessageCount);
  rb_define_alloc_func(SwigClassApplTotalMessageCount.klass, _wrap_ApplTotalMessageCount_allocate);
  rb_define_method(SwigClassApplTotalMessageCount.klass, "initialize", VALUEFUNC(_wrap_new_ApplTotalMessageCount), -1);
  SwigClassApplTotalMessageCount.mark = 0;
  SwigClassApplTotalMessageCount.destroy = (void (*)(void *)) free_FIX_ApplTotalMessageCount;
  SwigClassApplTotalMessageCount.trackObjects = 0;
  
  SwigClassInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "InstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartySubID, (void *) &SwigClassInstrumentPartySubID);
  rb_define_alloc_func(SwigClassInstrumentPartySubID.klass, _wrap_InstrumentPartySubID_allocate);
  rb_define_method(SwigClassInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartySubID), -1);
  SwigClassInstrumentPartySubID.mark = 0;
  SwigClassInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_InstrumentPartySubID;
  SwigClassInstrumentPartySubID.trackObjects = 0;
  
  SwigClassCustomerOrFirm.klass = rb_define_class_under(mQuickfix, "CustomerOrFirm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustomerOrFirm, (void *) &SwigClassCustomerOrFirm);
  rb_define_alloc_func(SwigClassCustomerOrFirm.klass, _wrap_CustomerOrFirm_allocate);
  rb_define_method(SwigClassCustomerOrFirm.klass, "initialize", VALUEFUNC(_wrap_new_CustomerOrFirm), -1);
  SwigClassCustomerOrFirm.mark = 0;
  SwigClassCustomerOrFirm.destroy = (void (*)(void *)) free_FIX_CustomerOrFirm;
  SwigClassCustomerOrFirm.trackObjects = 0;
  
  SwigClassAdjustmentType.klass = rb_define_class_under(mQuickfix, "AdjustmentType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdjustmentType, (void *) &SwigClassAdjustmentType);
  rb_define_alloc_func(SwigClassAdjustmentType.klass, _wrap_AdjustmentType_allocate);
  rb_define_method(SwigClassAdjustmentType.klass, "initialize", VALUEFUNC(_wrap_new_AdjustmentType), -1);
  SwigClassAdjustmentType.mark = 0;
  SwigClassAdjustmentType.destroy = (void (*)(void *)) free_FIX_AdjustmentType;
  SwigClassAdjustmentType.trackObjects = 0;
  
  SwigClassUnderlyingInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID, (void *) &SwigClassUnderlyingInstrumentPartyID);
  rb_define_alloc_func(SwigClassUnderlyingInstrumentPartyID.klass, _wrap_UnderlyingInstrumentPartyID_allocate);
  rb_define_method(SwigClassUnderlyingInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartyID), -1);
  SwigClassUnderlyingInstrumentPartyID.mark = 0;
  SwigClassUnderlyingInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartyID;
  SwigClassUnderlyingInstrumentPartyID.trackObjects = 0;
  
  SwigClassAsOfIndicator.klass = rb_define_class_under(mQuickfix, "AsOfIndicator", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AsOfIndicator, (void *) &SwigClassAsOfIndicator);
  rb_define_alloc_func(SwigClassAsOfIndicator.klass, _wrap_AsOfIndicator_allocate);
  rb_define_method(SwigClassAsOfIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AsOfIndicator), -1);
  SwigClassAsOfIndicator.mark = 0;
  SwigClassAsOfIndicator.destroy = (void (*)(void *)) free_FIX_AsOfIndicator;
  SwigClassAsOfIndicator.trackObjects = 0;
  
  SwigClassQuoteStatusReqID.klass = rb_define_class_under(mQuickfix, "QuoteStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteStatusReqID, (void *) &SwigClassQuoteStatusReqID);
  rb_define_alloc_func(SwigClassQuoteStatusReqID.klass, _wrap_QuoteStatusReqID_allocate);
  rb_define_method(SwigClassQuoteStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteStatusReqID), -1);
  SwigClassQuoteStatusReqID.mark = 0;
  SwigClassQuoteStatusReqID.destroy = (void (*)(void *)) free_FIX_QuoteStatusReqID;
  SwigClassQuoteStatusReqID.trackObjects = 0;
  
  SwigClassLegPositionEffect.klass = rb_define_class_under(mQuickfix, "LegPositionEffect", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPositionEffect, (void *) &SwigClassLegPositionEffect);
  rb_define_alloc_func(SwigClassLegPositionEffect.klass, _wrap_LegPositionEffect_allocate);
  rb_define_method(SwigClassLegPositionEffect.klass, "initialize", VALUEFUNC(_wrap_new_LegPositionEffect), -1);
  SwigClassLegPositionEffect.mark = 0;
  SwigClassLegPositionEffect.destroy = (void (*)(void *)) free_FIX_LegPositionEffect;
  SwigClassLegPositionEffect.trackObjects = 0;
  
  SwigClassMDEntryPx.klass = rb_define_class_under(mQuickfix, "MDEntryPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryPx, (void *) &SwigClassMDEntryPx);
  rb_define_alloc_func(SwigClassMDEntryPx.klass, _wrap_MDEntryPx_allocate);
  rb_define_method(SwigClassMDEntryPx.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryPx), -1);
  SwigClassMDEntryPx.mark = 0;
  SwigClassMDEntryPx.destroy = (void (*)(void *)) free_FIX_MDEntryPx;
  SwigClassMDEntryPx.trackObjects = 0;
  
  SwigClassMassActionScope.klass = rb_define_class_under(mQuickfix, "MassActionScope", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionScope, (void *) &SwigClassMassActionScope);
  rb_define_alloc_func(SwigClassMassActionScope.klass, _wrap_MassActionScope_allocate);
  rb_define_method(SwigClassMassActionScope.klass, "initialize", VALUEFUNC(_wrap_new_MassActionScope), -1);
  SwigClassMassActionScope.mark = 0;
  SwigClassMassActionScope.destroy = (void (*)(void *)) free_FIX_MassActionScope;
  SwigClassMassActionScope.trackObjects = 0;
  
  SwigClassReportedPxDiff.klass = rb_define_class_under(mQuickfix, "ReportedPxDiff", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReportedPxDiff, (void *) &SwigClassReportedPxDiff);
  rb_define_alloc_func(SwigClassReportedPxDiff.klass, _wrap_ReportedPxDiff_allocate);
  rb_define_method(SwigClassReportedPxDiff.klass, "initialize", VALUEFUNC(_wrap_new_ReportedPxDiff), -1);
  SwigClassReportedPxDiff.mark = 0;
  SwigClassReportedPxDiff.destroy = (void (*)(void *)) free_FIX_ReportedPxDiff;
  SwigClassReportedPxDiff.trackObjects = 0;
  
  SwigClassUnderlyingSettlementDate.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlementDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlementDate, (void *) &SwigClassUnderlyingSettlementDate);
  rb_define_alloc_func(SwigClassUnderlyingSettlementDate.klass, _wrap_UnderlyingSettlementDate_allocate);
  rb_define_method(SwigClassUnderlyingSettlementDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlementDate), -1);
  SwigClassUnderlyingSettlementDate.mark = 0;
  SwigClassUnderlyingSettlementDate.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlementDate;
  SwigClassUnderlyingSettlementDate.trackObjects = 0;
  
  SwigClassNoNestedPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNestedPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNestedPartySubIDs, (void *) &SwigClassNoNestedPartySubIDs);
  rb_define_alloc_func(SwigClassNoNestedPartySubIDs.klass, _wrap_NoNestedPartySubIDs_allocate);
  rb_define_method(SwigClassNoNestedPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNestedPartySubIDs), -1);
  SwigClassNoNestedPartySubIDs.mark = 0;
  SwigClassNoNestedPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNestedPartySubIDs;
  SwigClassNoNestedPartySubIDs.trackObjects = 0;
  
  SwigClassAllocReportRefID.klass = rb_define_class_under(mQuickfix, "AllocReportRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocReportRefID, (void *) &SwigClassAllocReportRefID);
  rb_define_alloc_func(SwigClassAllocReportRefID.klass, _wrap_AllocReportRefID_allocate);
  rb_define_method(SwigClassAllocReportRefID.klass, "initialize", VALUEFUNC(_wrap_new_AllocReportRefID), -1);
  SwigClassAllocReportRefID.mark = 0;
  SwigClassAllocReportRefID.destroy = (void (*)(void *)) free_FIX_AllocReportRefID;
  SwigClassAllocReportRefID.trackObjects = 0;
  
  SwigClassConcession.klass = rb_define_class_under(mQuickfix, "Concession", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Concession, (void *) &SwigClassConcession);
  rb_define_alloc_func(SwigClassConcession.klass, _wrap_Concession_allocate);
  rb_define_method(SwigClassConcession.klass, "initialize", VALUEFUNC(_wrap_new_Concession), -1);
  SwigClassConcession.mark = 0;
  SwigClassConcession.destroy = (void (*)(void *)) free_FIX_Concession;
  SwigClassConcession.trackObjects = 0;
  
  SwigClassEncodedSecurityDesc.klass = rb_define_class_under(mQuickfix, "EncodedSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityDesc, (void *) &SwigClassEncodedSecurityDesc);
  rb_define_alloc_func(SwigClassEncodedSecurityDesc.klass, _wrap_EncodedSecurityDesc_allocate);
  rb_define_method(SwigClassEncodedSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityDesc), -1);
  SwigClassEncodedSecurityDesc.mark = 0;
  SwigClassEncodedSecurityDesc.destroy = (void (*)(void *)) free_FIX_EncodedSecurityDesc;
  SwigClassEncodedSecurityDesc.trackObjects = 0;
  
  SwigClassExecRefID.klass = rb_define_class_under(mQuickfix, "ExecRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecRefID, (void *) &SwigClassExecRefID);
  rb_define_alloc_func(SwigClassExecRefID.klass, _wrap_ExecRefID_allocate);
  rb_define_method(SwigClassExecRefID.klass, "initialize", VALUEFUNC(_wrap_new_ExecRefID), -1);
  SwigClassExecRefID.mark = 0;
  SwigClassExecRefID.destroy = (void (*)(void *)) free_FIX_ExecRefID;
  SwigClassExecRefID.trackObjects = 0;
  
  SwigClassVenueType.klass = rb_define_class_under(mQuickfix, "VenueType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__VenueType, (void *) &SwigClassVenueType);
  rb_define_alloc_func(SwigClassVenueType.klass, _wrap_VenueType_allocate);
  rb_define_method(SwigClassVenueType.klass, "initialize", VALUEFUNC(_wrap_new_VenueType), -1);
  SwigClassVenueType.mark = 0;
  SwigClassVenueType.destroy = (void (*)(void *)) free_FIX_VenueType;
  SwigClassVenueType.trackObjects = 0;
  
  SwigClassMassActionType.klass = rb_define_class_under(mQuickfix, "MassActionType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionType, (void *) &SwigClassMassActionType);
  rb_define_alloc_func(SwigClassMassActionType.klass, _wrap_MassActionType_allocate);
  rb_define_method(SwigClassMassActionType.klass, "initialize", VALUEFUNC(_wrap_new_MassActionType), -1);
  SwigClassMassActionType.mark = 0;
  SwigClassMassActionType.destroy = (void (*)(void *)) free_FIX_MassActionType;
  SwigClassMassActionType.trackObjects = 0;
  
  SwigClassPosMaintResult.klass = rb_define_class_under(mQuickfix, "PosMaintResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintResult, (void *) &SwigClassPosMaintResult);
  rb_define_alloc_func(SwigClassPosMaintResult.klass, _wrap_PosMaintResult_allocate);
  rb_define_method(SwigClassPosMaintResult.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintResult), -1);
  SwigClassPosMaintResult.mark = 0;
  SwigClassPosMaintResult.destroy = (void (*)(void *)) free_FIX_PosMaintResult;
  SwigClassPosMaintResult.trackObjects = 0;
  
  SwigClassIOIShares.klass = rb_define_class_under(mQuickfix, "IOIShares", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIShares, (void *) &SwigClassIOIShares);
  rb_define_alloc_func(SwigClassIOIShares.klass, _wrap_IOIShares_allocate);
  rb_define_method(SwigClassIOIShares.klass, "initialize", VALUEFUNC(_wrap_new_IOIShares), -1);
  SwigClassIOIShares.mark = 0;
  SwigClassIOIShares.destroy = (void (*)(void *)) free_FIX_IOIShares;
  SwigClassIOIShares.trackObjects = 0;
  
  SwigClassBenchmarkSecurityID.klass = rb_define_class_under(mQuickfix, "BenchmarkSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkSecurityID, (void *) &SwigClassBenchmarkSecurityID);
  rb_define_alloc_func(SwigClassBenchmarkSecurityID.klass, _wrap_BenchmarkSecurityID_allocate);
  rb_define_method(SwigClassBenchmarkSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkSecurityID), -1);
  SwigClassBenchmarkSecurityID.mark = 0;
  SwigClassBenchmarkSecurityID.destroy = (void (*)(void *)) free_FIX_BenchmarkSecurityID;
  SwigClassBenchmarkSecurityID.trackObjects = 0;
  
  SwigClassLegLastQty.klass = rb_define_class_under(mQuickfix, "LegLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLastQty, (void *) &SwigClassLegLastQty);
  rb_define_alloc_func(SwigClassLegLastQty.klass, _wrap_LegLastQty_allocate);
  rb_define_method(SwigClassLegLastQty.klass, "initialize", VALUEFUNC(_wrap_new_LegLastQty), -1);
  SwigClassLegLastQty.mark = 0;
  SwigClassLegLastQty.destroy = (void (*)(void *)) free_FIX_LegLastQty;
  SwigClassLegLastQty.trackObjects = 0;
  
  SwigClassAllocSettlCurrency.klass = rb_define_class_under(mQuickfix, "AllocSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocSettlCurrency, (void *) &SwigClassAllocSettlCurrency);
  rb_define_alloc_func(SwigClassAllocSettlCurrency.klass, _wrap_AllocSettlCurrency_allocate);
  rb_define_method(SwigClassAllocSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_AllocSettlCurrency), -1);
  SwigClassAllocSettlCurrency.mark = 0;
  SwigClassAllocSettlCurrency.destroy = (void (*)(void *)) free_FIX_AllocSettlCurrency;
  SwigClassAllocSettlCurrency.trackObjects = 0;
  
  SwigClassLegCountryOfIssue.klass = rb_define_class_under(mQuickfix, "LegCountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCountryOfIssue, (void *) &SwigClassLegCountryOfIssue);
  rb_define_alloc_func(SwigClassLegCountryOfIssue.klass, _wrap_LegCountryOfIssue_allocate);
  rb_define_method(SwigClassLegCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LegCountryOfIssue), -1);
  SwigClassLegCountryOfIssue.mark = 0;
  SwigClassLegCountryOfIssue.destroy = (void (*)(void *)) free_FIX_LegCountryOfIssue;
  SwigClassLegCountryOfIssue.trackObjects = 0;
  
  SwigClassDerivativeSecurityXML.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityXML", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityXML, (void *) &SwigClassDerivativeSecurityXML);
  rb_define_alloc_func(SwigClassDerivativeSecurityXML.klass, _wrap_DerivativeSecurityXML_allocate);
  rb_define_method(SwigClassDerivativeSecurityXML.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityXML), -1);
  SwigClassDerivativeSecurityXML.mark = 0;
  SwigClassDerivativeSecurityXML.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityXML;
  SwigClassDerivativeSecurityXML.trackObjects = 0;
  
  SwigClassStrikeRuleID.klass = rb_define_class_under(mQuickfix, "StrikeRuleID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeRuleID, (void *) &SwigClassStrikeRuleID);
  rb_define_alloc_func(SwigClassStrikeRuleID.klass, _wrap_StrikeRuleID_allocate);
  rb_define_method(SwigClassStrikeRuleID.klass, "initialize", VALUEFUNC(_wrap_new_StrikeRuleID), -1);
  SwigClassStrikeRuleID.mark = 0;
  SwigClassStrikeRuleID.destroy = (void (*)(void *)) free_FIX_StrikeRuleID;
  SwigClassStrikeRuleID.trackObjects = 0;
  
  SwigClassRefCompID.klass = rb_define_class_under(mQuickfix, "RefCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefCompID, (void *) &SwigClassRefCompID);
  rb_define_alloc_func(SwigClassRefCompID.klass, _wrap_RefCompID_allocate);
  rb_define_method(SwigClassRefCompID.klass, "initialize", VALUEFUNC(_wrap_new_RefCompID), -1);
  SwigClassRefCompID.mark = 0;
  SwigClassRefCompID.destroy = (void (*)(void *)) free_FIX_RefCompID;
  SwigClassRefCompID.trackObjects = 0;
  
  SwigClassSettlCurrOfferFxRate.klass = rb_define_class_under(mQuickfix, "SettlCurrOfferFxRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrOfferFxRate, (void *) &SwigClassSettlCurrOfferFxRate);
  rb_define_alloc_func(SwigClassSettlCurrOfferFxRate.klass, _wrap_SettlCurrOfferFxRate_allocate);
  rb_define_method(SwigClassSettlCurrOfferFxRate.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrOfferFxRate), -1);
  SwigClassSettlCurrOfferFxRate.mark = 0;
  SwigClassSettlCurrOfferFxRate.destroy = (void (*)(void *)) free_FIX_SettlCurrOfferFxRate;
  SwigClassSettlCurrOfferFxRate.trackObjects = 0;
  
  SwigClassOfferYield.klass = rb_define_class_under(mQuickfix, "OfferYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferYield, (void *) &SwigClassOfferYield);
  rb_define_alloc_func(SwigClassOfferYield.klass, _wrap_OfferYield_allocate);
  rb_define_method(SwigClassOfferYield.klass, "initialize", VALUEFUNC(_wrap_new_OfferYield), -1);
  SwigClassOfferYield.mark = 0;
  SwigClassOfferYield.destroy = (void (*)(void *)) free_FIX_OfferYield;
  SwigClassOfferYield.trackObjects = 0;
  
  SwigClassTargetPartyIDSource.klass = rb_define_class_under(mQuickfix, "TargetPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetPartyIDSource, (void *) &SwigClassTargetPartyIDSource);
  rb_define_alloc_func(SwigClassTargetPartyIDSource.klass, _wrap_TargetPartyIDSource_allocate);
  rb_define_method(SwigClassTargetPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_TargetPartyIDSource), -1);
  SwigClassTargetPartyIDSource.mark = 0;
  SwigClassTargetPartyIDSource.destroy = (void (*)(void *)) free_FIX_TargetPartyIDSource;
  SwigClassTargetPartyIDSource.trackObjects = 0;
  
  SwigClassEncryptedNewPasswordLen.klass = rb_define_class_under(mQuickfix, "EncryptedNewPasswordLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedNewPasswordLen, (void *) &SwigClassEncryptedNewPasswordLen);
  rb_define_alloc_func(SwigClassEncryptedNewPasswordLen.klass, _wrap_EncryptedNewPasswordLen_allocate);
  rb_define_method(SwigClassEncryptedNewPasswordLen.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedNewPasswordLen), -1);
  SwigClassEncryptedNewPasswordLen.mark = 0;
  SwigClassEncryptedNewPasswordLen.destroy = (void (*)(void *)) free_FIX_EncryptedNewPasswordLen;
  SwigClassEncryptedNewPasswordLen.trackObjects = 0;
  
  SwigClassNoPositions.klass = rb_define_class_under(mQuickfix, "NoPositions", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPositions, (void *) &SwigClassNoPositions);
  rb_define_alloc_func(SwigClassNoPositions.klass, _wrap_NoPositions_allocate);
  rb_define_method(SwigClassNoPositions.klass, "initialize", VALUEFUNC(_wrap_new_NoPositions), -1);
  SwigClassNoPositions.mark = 0;
  SwigClassNoPositions.destroy = (void (*)(void *)) free_FIX_NoPositions;
  SwigClassNoPositions.trackObjects = 0;
  
  SwigClassTotalAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "TotalAccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalAccruedInterestAmt, (void *) &SwigClassTotalAccruedInterestAmt);
  rb_define_alloc_func(SwigClassTotalAccruedInterestAmt.klass, _wrap_TotalAccruedInterestAmt_allocate);
  rb_define_method(SwigClassTotalAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_TotalAccruedInterestAmt), -1);
  SwigClassTotalAccruedInterestAmt.mark = 0;
  SwigClassTotalAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_TotalAccruedInterestAmt;
  SwigClassTotalAccruedInterestAmt.trackObjects = 0;
  
  SwigClassUnderlyingOptAttribute.klass = rb_define_class_under(mQuickfix, "UnderlyingOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingOptAttribute, (void *) &SwigClassUnderlyingOptAttribute);
  rb_define_alloc_func(SwigClassUnderlyingOptAttribute.klass, _wrap_UnderlyingOptAttribute_allocate);
  rb_define_method(SwigClassUnderlyingOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingOptAttribute), -1);
  SwigClassUnderlyingOptAttribute.mark = 0;
  SwigClassUnderlyingOptAttribute.destroy = (void (*)(void *)) free_FIX_UnderlyingOptAttribute;
  SwigClassUnderlyingOptAttribute.trackObjects = 0;
  
  SwigClassDerivativeInstrAttribValue.klass = rb_define_class_under(mQuickfix, "DerivativeInstrAttribValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrAttribValue, (void *) &SwigClassDerivativeInstrAttribValue);
  rb_define_alloc_func(SwigClassDerivativeInstrAttribValue.klass, _wrap_DerivativeInstrAttribValue_allocate);
  rb_define_method(SwigClassDerivativeInstrAttribValue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrAttribValue), -1);
  SwigClassDerivativeInstrAttribValue.mark = 0;
  SwigClassDerivativeInstrAttribValue.destroy = (void (*)(void *)) free_FIX_DerivativeInstrAttribValue;
  SwigClassDerivativeInstrAttribValue.trackObjects = 0;
  
  SwigClassInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "InstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartyIDSource, (void *) &SwigClassInstrumentPartyIDSource);
  rb_define_alloc_func(SwigClassInstrumentPartyIDSource.klass, _wrap_InstrumentPartyIDSource_allocate);
  rb_define_method(SwigClassInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartyIDSource), -1);
  SwigClassInstrumentPartyIDSource.mark = 0;
  SwigClassInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_InstrumentPartyIDSource;
  SwigClassInstrumentPartyIDSource.trackObjects = 0;
  
  SwigClassPegOffsetType.klass = rb_define_class_under(mQuickfix, "PegOffsetType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegOffsetType, (void *) &SwigClassPegOffsetType);
  rb_define_alloc_func(SwigClassPegOffsetType.klass, _wrap_PegOffsetType_allocate);
  rb_define_method(SwigClassPegOffsetType.klass, "initialize", VALUEFUNC(_wrap_new_PegOffsetType), -1);
  SwigClassPegOffsetType.mark = 0;
  SwigClassPegOffsetType.destroy = (void (*)(void *)) free_FIX_PegOffsetType;
  SwigClassPegOffsetType.trackObjects = 0;
  
  SwigClassMassCancelRejectReason.klass = rb_define_class_under(mQuickfix, "MassCancelRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassCancelRejectReason, (void *) &SwigClassMassCancelRejectReason);
  rb_define_alloc_func(SwigClassMassCancelRejectReason.klass, _wrap_MassCancelRejectReason_allocate);
  rb_define_method(SwigClassMassCancelRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_MassCancelRejectReason), -1);
  SwigClassMassCancelRejectReason.mark = 0;
  SwigClassMassCancelRejectReason.destroy = (void (*)(void *)) free_FIX_MassCancelRejectReason;
  SwigClassMassCancelRejectReason.trackObjects = 0;
  
  SwigClassResponseTransportType.klass = rb_define_class_under(mQuickfix, "ResponseTransportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ResponseTransportType, (void *) &SwigClassResponseTransportType);
  rb_define_alloc_func(SwigClassResponseTransportType.klass, _wrap_ResponseTransportType_allocate);
  rb_define_method(SwigClassResponseTransportType.klass, "initialize", VALUEFUNC(_wrap_new_ResponseTransportType), -1);
  SwigClassResponseTransportType.mark = 0;
  SwigClassResponseTransportType.destroy = (void (*)(void *)) free_FIX_ResponseTransportType;
  SwigClassResponseTransportType.trackObjects = 0;
  
  SwigClassLegSecurityIDSource.klass = rb_define_class_under(mQuickfix, "LegSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityIDSource, (void *) &SwigClassLegSecurityIDSource);
  rb_define_alloc_func(SwigClassLegSecurityIDSource.klass, _wrap_LegSecurityIDSource_allocate);
  rb_define_method(SwigClassLegSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityIDSource), -1);
  SwigClassLegSecurityIDSource.mark = 0;
  SwigClassLegSecurityIDSource.destroy = (void (*)(void *)) free_FIX_LegSecurityIDSource;
  SwigClassLegSecurityIDSource.trackObjects = 0;
  
  SwigClassBasisFeaturePrice.klass = rb_define_class_under(mQuickfix, "BasisFeaturePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BasisFeaturePrice, (void *) &SwigClassBasisFeaturePrice);
  rb_define_alloc_func(SwigClassBasisFeaturePrice.klass, _wrap_BasisFeaturePrice_allocate);
  rb_define_method(SwigClassBasisFeaturePrice.klass, "initialize", VALUEFUNC(_wrap_new_BasisFeaturePrice), -1);
  SwigClassBasisFeaturePrice.mark = 0;
  SwigClassBasisFeaturePrice.destroy = (void (*)(void *)) free_FIX_BasisFeaturePrice;
  SwigClassBasisFeaturePrice.trackObjects = 0;
  
  SwigClassCouponPaymentDate.klass = rb_define_class_under(mQuickfix, "CouponPaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CouponPaymentDate, (void *) &SwigClassCouponPaymentDate);
  rb_define_alloc_func(SwigClassCouponPaymentDate.klass, _wrap_CouponPaymentDate_allocate);
  rb_define_method(SwigClassCouponPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_CouponPaymentDate), -1);
  SwigClassCouponPaymentDate.mark = 0;
  SwigClassCouponPaymentDate.destroy = (void (*)(void *)) free_FIX_CouponPaymentDate;
  SwigClassCouponPaymentDate.trackObjects = 0;
  
  SwigClassTradSesStatusRejReason.klass = rb_define_class_under(mQuickfix, "TradSesStatusRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesStatusRejReason, (void *) &SwigClassTradSesStatusRejReason);
  rb_define_alloc_func(SwigClassTradSesStatusRejReason.klass, _wrap_TradSesStatusRejReason_allocate);
  rb_define_method(SwigClassTradSesStatusRejReason.klass, "initialize", VALUEFUNC(_wrap_new_TradSesStatusRejReason), -1);
  SwigClassTradSesStatusRejReason.mark = 0;
  SwigClassTradSesStatusRejReason.destroy = (void (*)(void *)) free_FIX_TradSesStatusRejReason;
  SwigClassTradSesStatusRejReason.trackObjects = 0;
  
  SwigClassUnderlyingDetachmentPoint.klass = rb_define_class_under(mQuickfix, "UnderlyingDetachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingDetachmentPoint, (void *) &SwigClassUnderlyingDetachmentPoint);
  rb_define_alloc_func(SwigClassUnderlyingDetachmentPoint.klass, _wrap_UnderlyingDetachmentPoint_allocate);
  rb_define_method(SwigClassUnderlyingDetachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingDetachmentPoint), -1);
  SwigClassUnderlyingDetachmentPoint.mark = 0;
  SwigClassUnderlyingDetachmentPoint.destroy = (void (*)(void *)) free_FIX_UnderlyingDetachmentPoint;
  SwigClassUnderlyingDetachmentPoint.trackObjects = 0;
  
  SwigClassMaturityRuleID.klass = rb_define_class_under(mQuickfix, "MaturityRuleID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityRuleID, (void *) &SwigClassMaturityRuleID);
  rb_define_alloc_func(SwigClassMaturityRuleID.klass, _wrap_MaturityRuleID_allocate);
  rb_define_method(SwigClassMaturityRuleID.klass, "initialize", VALUEFUNC(_wrap_new_MaturityRuleID), -1);
  SwigClassMaturityRuleID.mark = 0;
  SwigClassMaturityRuleID.destroy = (void (*)(void *)) free_FIX_MaturityRuleID;
  SwigClassMaturityRuleID.trackObjects = 0;
  
  SwigClassUnderlyingRepoCollateralSecurityType.klass = rb_define_class_under(mQuickfix, "UnderlyingRepoCollateralSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType, (void *) &SwigClassUnderlyingRepoCollateralSecurityType);
  rb_define_alloc_func(SwigClassUnderlyingRepoCollateralSecurityType.klass, _wrap_UnderlyingRepoCollateralSecurityType_allocate);
  rb_define_method(SwigClassUnderlyingRepoCollateralSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRepoCollateralSecurityType), -1);
  SwigClassUnderlyingRepoCollateralSecurityType.mark = 0;
  SwigClassUnderlyingRepoCollateralSecurityType.destroy = (void (*)(void *)) free_FIX_UnderlyingRepoCollateralSecurityType;
  SwigClassUnderlyingRepoCollateralSecurityType.trackObjects = 0;
  
  SwigClassNoTimeInForceRules.klass = rb_define_class_under(mQuickfix, "NoTimeInForceRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTimeInForceRules, (void *) &SwigClassNoTimeInForceRules);
  rb_define_alloc_func(SwigClassNoTimeInForceRules.klass, _wrap_NoTimeInForceRules_allocate);
  rb_define_method(SwigClassNoTimeInForceRules.klass, "initialize", VALUEFUNC(_wrap_new_NoTimeInForceRules), -1);
  SwigClassNoTimeInForceRules.mark = 0;
  SwigClassNoTimeInForceRules.destroy = (void (*)(void *)) free_FIX_NoTimeInForceRules;
  SwigClassNoTimeInForceRules.trackObjects = 0;
  
  SwigClassNoRootPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoRootPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRootPartySubIDs, (void *) &SwigClassNoRootPartySubIDs);
  rb_define_alloc_func(SwigClassNoRootPartySubIDs.klass, _wrap_NoRootPartySubIDs_allocate);
  rb_define_method(SwigClassNoRootPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRootPartySubIDs), -1);
  SwigClassNoRootPartySubIDs.mark = 0;
  SwigClassNoRootPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoRootPartySubIDs;
  SwigClassNoRootPartySubIDs.trackObjects = 0;
  
  SwigClassDisplayMinIncr.klass = rb_define_class_under(mQuickfix, "DisplayMinIncr", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayMinIncr, (void *) &SwigClassDisplayMinIncr);
  rb_define_alloc_func(SwigClassDisplayMinIncr.klass, _wrap_DisplayMinIncr_allocate);
  rb_define_method(SwigClassDisplayMinIncr.klass, "initialize", VALUEFUNC(_wrap_new_DisplayMinIncr), -1);
  SwigClassDisplayMinIncr.mark = 0;
  SwigClassDisplayMinIncr.destroy = (void (*)(void *)) free_FIX_DisplayMinIncr;
  SwigClassDisplayMinIncr.trackObjects = 0;
  
  SwigClassTrdRegTimestampType.klass = rb_define_class_under(mQuickfix, "TrdRegTimestampType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRegTimestampType, (void *) &SwigClassTrdRegTimestampType);
  rb_define_alloc_func(SwigClassTrdRegTimestampType.klass, _wrap_TrdRegTimestampType_allocate);
  rb_define_method(SwigClassTrdRegTimestampType.klass, "initialize", VALUEFUNC(_wrap_new_TrdRegTimestampType), -1);
  SwigClassTrdRegTimestampType.mark = 0;
  SwigClassTrdRegTimestampType.destroy = (void (*)(void *)) free_FIX_TrdRegTimestampType;
  SwigClassTrdRegTimestampType.trackObjects = 0;
  
  SwigClassLegProduct.klass = rb_define_class_under(mQuickfix, "LegProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegProduct, (void *) &SwigClassLegProduct);
  rb_define_alloc_func(SwigClassLegProduct.klass, _wrap_LegProduct_allocate);
  rb_define_method(SwigClassLegProduct.klass, "initialize", VALUEFUNC(_wrap_new_LegProduct), -1);
  SwigClassLegProduct.mark = 0;
  SwigClassLegProduct.destroy = (void (*)(void *)) free_FIX_LegProduct;
  SwigClassLegProduct.trackObjects = 0;
  
  SwigClassApplVerID.klass = rb_define_class_under(mQuickfix, "ApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplVerID, (void *) &SwigClassApplVerID);
  rb_define_alloc_func(SwigClassApplVerID.klass, _wrap_ApplVerID_allocate);
  rb_define_method(SwigClassApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_ApplVerID), -1);
  SwigClassApplVerID.mark = 0;
  SwigClassApplVerID.destroy = (void (*)(void *)) free_FIX_ApplVerID;
  SwigClassApplVerID.trackObjects = 0;
  
  SwigClassHandlInst.klass = rb_define_class_under(mQuickfix, "HandlInst", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HandlInst, (void *) &SwigClassHandlInst);
  rb_define_alloc_func(SwigClassHandlInst.klass, _wrap_HandlInst_allocate);
  rb_define_method(SwigClassHandlInst.klass, "initialize", VALUEFUNC(_wrap_new_HandlInst), -1);
  SwigClassHandlInst.mark = 0;
  SwigClassHandlInst.destroy = (void (*)(void *)) free_FIX_HandlInst;
  SwigClassHandlInst.trackObjects = 0;
  
  SwigClassListUpdateAction.klass = rb_define_class_under(mQuickfix, "ListUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListUpdateAction, (void *) &SwigClassListUpdateAction);
  rb_define_alloc_func(SwigClassListUpdateAction.klass, _wrap_ListUpdateAction_allocate);
  rb_define_method(SwigClassListUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_ListUpdateAction), -1);
  SwigClassListUpdateAction.mark = 0;
  SwigClassListUpdateAction.destroy = (void (*)(void *)) free_FIX_ListUpdateAction;
  SwigClassListUpdateAction.trackObjects = 0;
  
  SwigClassNestedInstrAttribValue.klass = rb_define_class_under(mQuickfix, "NestedInstrAttribValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedInstrAttribValue, (void *) &SwigClassNestedInstrAttribValue);
  rb_define_alloc_func(SwigClassNestedInstrAttribValue.klass, _wrap_NestedInstrAttribValue_allocate);
  rb_define_method(SwigClassNestedInstrAttribValue.klass, "initialize", VALUEFUNC(_wrap_new_NestedInstrAttribValue), -1);
  SwigClassNestedInstrAttribValue.mark = 0;
  SwigClassNestedInstrAttribValue.destroy = (void (*)(void *)) free_FIX_NestedInstrAttribValue;
  SwigClassNestedInstrAttribValue.trackObjects = 0;
  
  SwigClassTradingSessionSubID.klass = rb_define_class_under(mQuickfix, "TradingSessionSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingSessionSubID, (void *) &SwigClassTradingSessionSubID);
  rb_define_alloc_func(SwigClassTradingSessionSubID.klass, _wrap_TradingSessionSubID_allocate);
  rb_define_method(SwigClassTradingSessionSubID.klass, "initialize", VALUEFUNC(_wrap_new_TradingSessionSubID), -1);
  SwigClassTradingSessionSubID.mark = 0;
  SwigClassTradingSessionSubID.destroy = (void (*)(void *)) free_FIX_TradingSessionSubID;
  SwigClassTradingSessionSubID.trackObjects = 0;
  
  SwigClassRFQReqID.klass = rb_define_class_under(mQuickfix, "RFQReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RFQReqID, (void *) &SwigClassRFQReqID);
  rb_define_alloc_func(SwigClassRFQReqID.klass, _wrap_RFQReqID_allocate);
  rb_define_method(SwigClassRFQReqID.klass, "initialize", VALUEFUNC(_wrap_new_RFQReqID), -1);
  SwigClassRFQReqID.mark = 0;
  SwigClassRFQReqID.destroy = (void (*)(void *)) free_FIX_RFQReqID;
  SwigClassRFQReqID.trackObjects = 0;
  
  SwigClassUnderlyingLegSymbolSfx.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx, (void *) &SwigClassUnderlyingLegSymbolSfx);
  rb_define_alloc_func(SwigClassUnderlyingLegSymbolSfx.klass, _wrap_UnderlyingLegSymbolSfx_allocate);
  rb_define_method(SwigClassUnderlyingLegSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSymbolSfx), -1);
  SwigClassUnderlyingLegSymbolSfx.mark = 0;
  SwigClassUnderlyingLegSymbolSfx.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSymbolSfx;
  SwigClassUnderlyingLegSymbolSfx.trackObjects = 0;
  
  SwigClassLiquidityNumSecurities.klass = rb_define_class_under(mQuickfix, "LiquidityNumSecurities", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityNumSecurities, (void *) &SwigClassLiquidityNumSecurities);
  rb_define_alloc_func(SwigClassLiquidityNumSecurities.klass, _wrap_LiquidityNumSecurities_allocate);
  rb_define_method(SwigClassLiquidityNumSecurities.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityNumSecurities), -1);
  SwigClassLiquidityNumSecurities.mark = 0;
  SwigClassLiquidityNumSecurities.destroy = (void (*)(void *)) free_FIX_LiquidityNumSecurities;
  SwigClassLiquidityNumSecurities.trackObjects = 0;
  
  SwigClassNoMsgTypes.klass = rb_define_class_under(mQuickfix, "NoMsgTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMsgTypes, (void *) &SwigClassNoMsgTypes);
  rb_define_alloc_func(SwigClassNoMsgTypes.klass, _wrap_NoMsgTypes_allocate);
  rb_define_method(SwigClassNoMsgTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoMsgTypes), -1);
  SwigClassNoMsgTypes.mark = 0;
  SwigClassNoMsgTypes.destroy = (void (*)(void *)) free_FIX_NoMsgTypes;
  SwigClassNoMsgTypes.trackObjects = 0;
  
  SwigClassTradSesStartTime.klass = rb_define_class_under(mQuickfix, "TradSesStartTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesStartTime, (void *) &SwigClassTradSesStartTime);
  rb_define_alloc_func(SwigClassTradSesStartTime.klass, _wrap_TradSesStartTime_allocate);
  rb_define_method(SwigClassTradSesStartTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesStartTime), -1);
  SwigClassTradSesStartTime.mark = 0;
  SwigClassTradSesStartTime.destroy = (void (*)(void *)) free_FIX_TradSesStartTime;
  SwigClassTradSesStartTime.trackObjects = 0;
  
  SwigClassMDEntryType.klass = rb_define_class_under(mQuickfix, "MDEntryType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryType, (void *) &SwigClassMDEntryType);
  rb_define_alloc_func(SwigClassMDEntryType.klass, _wrap_MDEntryType_allocate);
  rb_define_method(SwigClassMDEntryType.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryType), -1);
  SwigClassMDEntryType.mark = 0;
  SwigClassMDEntryType.destroy = (void (*)(void *)) free_FIX_MDEntryType;
  SwigClassMDEntryType.trackObjects = 0;
  
  SwigClassAgreementCurrency.klass = rb_define_class_under(mQuickfix, "AgreementCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementCurrency, (void *) &SwigClassAgreementCurrency);
  rb_define_alloc_func(SwigClassAgreementCurrency.klass, _wrap_AgreementCurrency_allocate);
  rb_define_method(SwigClassAgreementCurrency.klass, "initialize", VALUEFUNC(_wrap_new_AgreementCurrency), -1);
  SwigClassAgreementCurrency.mark = 0;
  SwigClassAgreementCurrency.destroy = (void (*)(void *)) free_FIX_AgreementCurrency;
  SwigClassAgreementCurrency.trackObjects = 0;
  
  SwigClassPegMoveType.klass = rb_define_class_under(mQuickfix, "PegMoveType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegMoveType, (void *) &SwigClassPegMoveType);
  rb_define_alloc_func(SwigClassPegMoveType.klass, _wrap_PegMoveType_allocate);
  rb_define_method(SwigClassPegMoveType.klass, "initialize", VALUEFUNC(_wrap_new_PegMoveType), -1);
  SwigClassPegMoveType.mark = 0;
  SwigClassPegMoveType.destroy = (void (*)(void *)) free_FIX_PegMoveType;
  SwigClassPegMoveType.trackObjects = 0;
  
  SwigClassPegDifference.klass = rb_define_class_under(mQuickfix, "PegDifference", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegDifference, (void *) &SwigClassPegDifference);
  rb_define_alloc_func(SwigClassPegDifference.klass, _wrap_PegDifference_allocate);
  rb_define_method(SwigClassPegDifference.klass, "initialize", VALUEFUNC(_wrap_new_PegDifference), -1);
  SwigClassPegDifference.mark = 0;
  SwigClassPegDifference.destroy = (void (*)(void *)) free_FIX_PegDifference;
  SwigClassPegDifference.trackObjects = 0;
  
  SwigClassSpread.klass = rb_define_class_under(mQuickfix, "Spread", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Spread, (void *) &SwigClassSpread);
  rb_define_alloc_func(SwigClassSpread.klass, _wrap_Spread_allocate);
  rb_define_method(SwigClassSpread.klass, "initialize", VALUEFUNC(_wrap_new_Spread), -1);
  SwigClassSpread.mark = 0;
  SwigClassSpread.destroy = (void (*)(void *)) free_FIX_Spread;
  SwigClassSpread.trackObjects = 0;
  
  SwigClassEncodedAllocTextLen.klass = rb_define_class_under(mQuickfix, "EncodedAllocTextLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedAllocTextLen, (void *) &SwigClassEncodedAllocTextLen);
  rb_define_alloc_func(SwigClassEncodedAllocTextLen.klass, _wrap_EncodedAllocTextLen_allocate);
  rb_define_method(SwigClassEncodedAllocTextLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedAllocTextLen), -1);
  SwigClassEncodedAllocTextLen.mark = 0;
  SwigClassEncodedAllocTextLen.destroy = (void (*)(void *)) free_FIX_EncodedAllocTextLen;
  SwigClassEncodedAllocTextLen.trackObjects = 0;
  
  SwigClassOutsideIndexPct.klass = rb_define_class_under(mQuickfix, "OutsideIndexPct", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OutsideIndexPct, (void *) &SwigClassOutsideIndexPct);
  rb_define_alloc_func(SwigClassOutsideIndexPct.klass, _wrap_OutsideIndexPct_allocate);
  rb_define_method(SwigClassOutsideIndexPct.klass, "initialize", VALUEFUNC(_wrap_new_OutsideIndexPct), -1);
  SwigClassOutsideIndexPct.mark = 0;
  SwigClassOutsideIndexPct.destroy = (void (*)(void *)) free_FIX_OutsideIndexPct;
  SwigClassOutsideIndexPct.trackObjects = 0;
  
  SwigClassDerivFlexProductEligibilityIndicator.klass = rb_define_class_under(mQuickfix, "DerivFlexProductEligibilityIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator, (void *) &SwigClassDerivFlexProductEligibilityIndicator);
  rb_define_alloc_func(SwigClassDerivFlexProductEligibilityIndicator.klass, _wrap_DerivFlexProductEligibilityIndicator_allocate);
  rb_define_method(SwigClassDerivFlexProductEligibilityIndicator.klass, "initialize", VALUEFUNC(_wrap_new_DerivFlexProductEligibilityIndicator), -1);
  SwigClassDerivFlexProductEligibilityIndicator.mark = 0;
  SwigClassDerivFlexProductEligibilityIndicator.destroy = (void (*)(void *)) free_FIX_DerivFlexProductEligibilityIndicator;
  SwigClassDerivFlexProductEligibilityIndicator.trackObjects = 0;
  
  SwigClassAvgPxIndicator.klass = rb_define_class_under(mQuickfix, "AvgPxIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPxIndicator, (void *) &SwigClassAvgPxIndicator);
  rb_define_alloc_func(SwigClassAvgPxIndicator.klass, _wrap_AvgPxIndicator_allocate);
  rb_define_method(SwigClassAvgPxIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AvgPxIndicator), -1);
  SwigClassAvgPxIndicator.mark = 0;
  SwigClassAvgPxIndicator.destroy = (void (*)(void *)) free_FIX_AvgPxIndicator;
  SwigClassAvgPxIndicator.trackObjects = 0;
  
  SwigClassNoIOIQualifiers.klass = rb_define_class_under(mQuickfix, "NoIOIQualifiers", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoIOIQualifiers, (void *) &SwigClassNoIOIQualifiers);
  rb_define_alloc_func(SwigClassNoIOIQualifiers.klass, _wrap_NoIOIQualifiers_allocate);
  rb_define_method(SwigClassNoIOIQualifiers.klass, "initialize", VALUEFUNC(_wrap_new_NoIOIQualifiers), -1);
  SwigClassNoIOIQualifiers.mark = 0;
  SwigClassNoIOIQualifiers.destroy = (void (*)(void *)) free_FIX_NoIOIQualifiers;
  SwigClassNoIOIQualifiers.trackObjects = 0;
  
  SwigClassCancellationRights.klass = rb_define_class_under(mQuickfix, "CancellationRights", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CancellationRights, (void *) &SwigClassCancellationRights);
  rb_define_alloc_func(SwigClassCancellationRights.klass, _wrap_CancellationRights_allocate);
  rb_define_method(SwigClassCancellationRights.klass, "initialize", VALUEFUNC(_wrap_new_CancellationRights), -1);
  SwigClassCancellationRights.mark = 0;
  SwigClassCancellationRights.destroy = (void (*)(void *)) free_FIX_CancellationRights;
  SwigClassCancellationRights.trackObjects = 0;
  
  SwigClassListSeqNo.klass = rb_define_class_under(mQuickfix, "ListSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListSeqNo, (void *) &SwigClassListSeqNo);
  rb_define_alloc_func(SwigClassListSeqNo.klass, _wrap_ListSeqNo_allocate);
  rb_define_method(SwigClassListSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_ListSeqNo), -1);
  SwigClassListSeqNo.mark = 0;
  SwigClassListSeqNo.destroy = (void (*)(void *)) free_FIX_ListSeqNo;
  SwigClassListSeqNo.trackObjects = 0;
  
  SwigClassCardIssNum.klass = rb_define_class_under(mQuickfix, "CardIssNum", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardIssNum, (void *) &SwigClassCardIssNum);
  rb_define_alloc_func(SwigClassCardIssNum.klass, _wrap_CardIssNum_allocate);
  rb_define_method(SwigClassCardIssNum.klass, "initialize", VALUEFUNC(_wrap_new_CardIssNum), -1);
  SwigClassCardIssNum.mark = 0;
  SwigClassCardIssNum.destroy = (void (*)(void *)) free_FIX_CardIssNum;
  SwigClassCardIssNum.trackObjects = 0;
  
  SwigClassEncodedMktSegmDesc.klass = rb_define_class_under(mQuickfix, "EncodedMktSegmDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedMktSegmDesc, (void *) &SwigClassEncodedMktSegmDesc);
  rb_define_alloc_func(SwigClassEncodedMktSegmDesc.klass, _wrap_EncodedMktSegmDesc_allocate);
  rb_define_method(SwigClassEncodedMktSegmDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedMktSegmDesc), -1);
  SwigClassEncodedMktSegmDesc.mark = 0;
  SwigClassEncodedMktSegmDesc.destroy = (void (*)(void *)) free_FIX_EncodedMktSegmDesc;
  SwigClassEncodedMktSegmDesc.trackObjects = 0;
  
  SwigClassDerivativeEventType.klass = rb_define_class_under(mQuickfix, "DerivativeEventType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventType, (void *) &SwigClassDerivativeEventType);
  rb_define_alloc_func(SwigClassDerivativeEventType.klass, _wrap_DerivativeEventType_allocate);
  rb_define_method(SwigClassDerivativeEventType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventType), -1);
  SwigClassDerivativeEventType.mark = 0;
  SwigClassDerivativeEventType.destroy = (void (*)(void *)) free_FIX_DerivativeEventType;
  SwigClassDerivativeEventType.trackObjects = 0;
  
  SwigClassDerivativeMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "DerivativeMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMaturityMonthYear, (void *) &SwigClassDerivativeMaturityMonthYear);
  rb_define_alloc_func(SwigClassDerivativeMaturityMonthYear.klass, _wrap_DerivativeMaturityMonthYear_allocate);
  rb_define_method(SwigClassDerivativeMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMaturityMonthYear), -1);
  SwigClassDerivativeMaturityMonthYear.mark = 0;
  SwigClassDerivativeMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_DerivativeMaturityMonthYear;
  SwigClassDerivativeMaturityMonthYear.trackObjects = 0;
  
  SwigClassSideTradeReportID.klass = rb_define_class_under(mQuickfix, "SideTradeReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTradeReportID, (void *) &SwigClassSideTradeReportID);
  rb_define_alloc_func(SwigClassSideTradeReportID.klass, _wrap_SideTradeReportID_allocate);
  rb_define_method(SwigClassSideTradeReportID.klass, "initialize", VALUEFUNC(_wrap_new_SideTradeReportID), -1);
  SwigClassSideTradeReportID.mark = 0;
  SwigClassSideTradeReportID.destroy = (void (*)(void *)) free_FIX_SideTradeReportID;
  SwigClassSideTradeReportID.trackObjects = 0;
  
  SwigClassNoQuoteSets.klass = rb_define_class_under(mQuickfix, "NoQuoteSets", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoQuoteSets, (void *) &SwigClassNoQuoteSets);
  rb_define_alloc_func(SwigClassNoQuoteSets.klass, _wrap_NoQuoteSets_allocate);
  rb_define_method(SwigClassNoQuoteSets.klass, "initialize", VALUEFUNC(_wrap_new_NoQuoteSets), -1);
  SwigClassNoQuoteSets.mark = 0;
  SwigClassNoQuoteSets.destroy = (void (*)(void *)) free_FIX_NoQuoteSets;
  SwigClassNoQuoteSets.trackObjects = 0;
  
  SwigClassNested4PartySubIDType.klass = rb_define_class_under(mQuickfix, "Nested4PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartySubIDType, (void *) &SwigClassNested4PartySubIDType);
  rb_define_alloc_func(SwigClassNested4PartySubIDType.klass, _wrap_Nested4PartySubIDType_allocate);
  rb_define_method(SwigClassNested4PartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartySubIDType), -1);
  SwigClassNested4PartySubIDType.mark = 0;
  SwigClassNested4PartySubIDType.destroy = (void (*)(void *)) free_FIX_Nested4PartySubIDType;
  SwigClassNested4PartySubIDType.trackObjects = 0;
  
  SwigClassFillPx.klass = rb_define_class_under(mQuickfix, "FillPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillPx, (void *) &SwigClassFillPx);
  rb_define_alloc_func(SwigClassFillPx.klass, _wrap_FillPx_allocate);
  rb_define_method(SwigClassFillPx.klass, "initialize", VALUEFUNC(_wrap_new_FillPx), -1);
  SwigClassFillPx.mark = 0;
  SwigClassFillPx.destroy = (void (*)(void *)) free_FIX_FillPx;
  SwigClassFillPx.trackObjects = 0;
  
  SwigClassStrikeExerciseStyle.klass = rb_define_class_under(mQuickfix, "StrikeExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeExerciseStyle, (void *) &SwigClassStrikeExerciseStyle);
  rb_define_alloc_func(SwigClassStrikeExerciseStyle.klass, _wrap_StrikeExerciseStyle_allocate);
  rb_define_method(SwigClassStrikeExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_StrikeExerciseStyle), -1);
  SwigClassStrikeExerciseStyle.mark = 0;
  SwigClassStrikeExerciseStyle.destroy = (void (*)(void *)) free_FIX_StrikeExerciseStyle;
  SwigClassStrikeExerciseStyle.trackObjects = 0;
  
  SwigClassDeskID.klass = rb_define_class_under(mQuickfix, "DeskID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskID, (void *) &SwigClassDeskID);
  rb_define_alloc_func(SwigClassDeskID.klass, _wrap_DeskID_allocate);
  rb_define_method(SwigClassDeskID.klass, "initialize", VALUEFUNC(_wrap_new_DeskID), -1);
  SwigClassDeskID.mark = 0;
  SwigClassDeskID.destroy = (void (*)(void *)) free_FIX_DeskID;
  SwigClassDeskID.trackObjects = 0;
  
  SwigClassCrossPercent.klass = rb_define_class_under(mQuickfix, "CrossPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossPercent, (void *) &SwigClassCrossPercent);
  rb_define_alloc_func(SwigClassCrossPercent.klass, _wrap_CrossPercent_allocate);
  rb_define_method(SwigClassCrossPercent.klass, "initialize", VALUEFUNC(_wrap_new_CrossPercent), -1);
  SwigClassCrossPercent.mark = 0;
  SwigClassCrossPercent.destroy = (void (*)(void *)) free_FIX_CrossPercent;
  SwigClassCrossPercent.trackObjects = 0;
  
  SwigClassMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "MaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYear, (void *) &SwigClassMaturityMonthYear);
  rb_define_alloc_func(SwigClassMaturityMonthYear.klass, _wrap_MaturityMonthYear_allocate);
  rb_define_method(SwigClassMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYear), -1);
  SwigClassMaturityMonthYear.mark = 0;
  SwigClassMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_MaturityMonthYear;
  SwigClassMaturityMonthYear.trackObjects = 0;
  
  SwigClassComplexEventPrice.klass = rb_define_class_under(mQuickfix, "ComplexEventPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPrice, (void *) &SwigClassComplexEventPrice);
  rb_define_alloc_func(SwigClassComplexEventPrice.klass, _wrap_ComplexEventPrice_allocate);
  rb_define_method(SwigClassComplexEventPrice.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPrice), -1);
  SwigClassComplexEventPrice.mark = 0;
  SwigClassComplexEventPrice.destroy = (void (*)(void *)) free_FIX_ComplexEventPrice;
  SwigClassComplexEventPrice.trackObjects = 0;
  
  SwigClassNoNewsRefIDs.klass = rb_define_class_under(mQuickfix, "NoNewsRefIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNewsRefIDs, (void *) &SwigClassNoNewsRefIDs);
  rb_define_alloc_func(SwigClassNoNewsRefIDs.klass, _wrap_NoNewsRefIDs_allocate);
  rb_define_method(SwigClassNoNewsRefIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNewsRefIDs), -1);
  SwigClassNoNewsRefIDs.mark = 0;
  SwigClassNoNewsRefIDs.destroy = (void (*)(void *)) free_FIX_NoNewsRefIDs;
  SwigClassNoNewsRefIDs.trackObjects = 0;
  
  SwigClassUnderlyingCapValue.klass = rb_define_class_under(mQuickfix, "UnderlyingCapValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCapValue, (void *) &SwigClassUnderlyingCapValue);
  rb_define_alloc_func(SwigClassUnderlyingCapValue.klass, _wrap_UnderlyingCapValue_allocate);
  rb_define_method(SwigClassUnderlyingCapValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCapValue), -1);
  SwigClassUnderlyingCapValue.mark = 0;
  SwigClassUnderlyingCapValue.destroy = (void (*)(void *)) free_FIX_UnderlyingCapValue;
  SwigClassUnderlyingCapValue.trackObjects = 0;
  
  SwigClassCPRegType.klass = rb_define_class_under(mQuickfix, "CPRegType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CPRegType, (void *) &SwigClassCPRegType);
  rb_define_alloc_func(SwigClassCPRegType.klass, _wrap_CPRegType_allocate);
  rb_define_method(SwigClassCPRegType.klass, "initialize", VALUEFUNC(_wrap_new_CPRegType), -1);
  SwigClassCPRegType.mark = 0;
  SwigClassCPRegType.destroy = (void (*)(void *)) free_FIX_CPRegType;
  SwigClassCPRegType.trackObjects = 0;
  
  SwigClassCashDistribAgentCode.klass = rb_define_class_under(mQuickfix, "CashDistribAgentCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentCode, (void *) &SwigClassCashDistribAgentCode);
  rb_define_alloc_func(SwigClassCashDistribAgentCode.klass, _wrap_CashDistribAgentCode_allocate);
  rb_define_method(SwigClassCashDistribAgentCode.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentCode), -1);
  SwigClassCashDistribAgentCode.mark = 0;
  SwigClassCashDistribAgentCode.destroy = (void (*)(void *)) free_FIX_CashDistribAgentCode;
  SwigClassCashDistribAgentCode.trackObjects = 0;
  
  SwigClassExecPriceType.klass = rb_define_class_under(mQuickfix, "ExecPriceType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecPriceType, (void *) &SwigClassExecPriceType);
  rb_define_alloc_func(SwigClassExecPriceType.klass, _wrap_ExecPriceType_allocate);
  rb_define_method(SwigClassExecPriceType.klass, "initialize", VALUEFUNC(_wrap_new_ExecPriceType), -1);
  SwigClassExecPriceType.mark = 0;
  SwigClassExecPriceType.destroy = (void (*)(void *)) free_FIX_ExecPriceType;
  SwigClassExecPriceType.trackObjects = 0;
  
  SwigClassLegAllocID.klass = rb_define_class_under(mQuickfix, "LegAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocID, (void *) &SwigClassLegAllocID);
  rb_define_alloc_func(SwigClassLegAllocID.klass, _wrap_LegAllocID_allocate);
  rb_define_method(SwigClassLegAllocID.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocID), -1);
  SwigClassLegAllocID.mark = 0;
  SwigClassLegAllocID.destroy = (void (*)(void *)) free_FIX_LegAllocID;
  SwigClassLegAllocID.trackObjects = 0;
  
  SwigClassMDEntryTime.klass = rb_define_class_under(mQuickfix, "MDEntryTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryTime, (void *) &SwigClassMDEntryTime);
  rb_define_alloc_func(SwigClassMDEntryTime.klass, _wrap_MDEntryTime_allocate);
  rb_define_method(SwigClassMDEntryTime.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryTime), -1);
  SwigClassMDEntryTime.mark = 0;
  SwigClassMDEntryTime.destroy = (void (*)(void *)) free_FIX_MDEntryTime;
  SwigClassMDEntryTime.trackObjects = 0;
  
  SwigClassTotalNumSecurities.klass = rb_define_class_under(mQuickfix, "TotalNumSecurities", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNumSecurities, (void *) &SwigClassTotalNumSecurities);
  rb_define_alloc_func(SwigClassTotalNumSecurities.klass, _wrap_TotalNumSecurities_allocate);
  rb_define_method(SwigClassTotalNumSecurities.klass, "initialize", VALUEFUNC(_wrap_new_TotalNumSecurities), -1);
  SwigClassTotalNumSecurities.mark = 0;
  SwigClassTotalNumSecurities.destroy = (void (*)(void *)) free_FIX_TotalNumSecurities;
  SwigClassTotalNumSecurities.trackObjects = 0;
  
  SwigClassAllocSettlInstType.klass = rb_define_class_under(mQuickfix, "AllocSettlInstType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocSettlInstType, (void *) &SwigClassAllocSettlInstType);
  rb_define_alloc_func(SwigClassAllocSettlInstType.klass, _wrap_AllocSettlInstType_allocate);
  rb_define_method(SwigClassAllocSettlInstType.klass, "initialize", VALUEFUNC(_wrap_new_AllocSettlInstType), -1);
  SwigClassAllocSettlInstType.mark = 0;
  SwigClassAllocSettlInstType.destroy = (void (*)(void *)) free_FIX_AllocSettlInstType;
  SwigClassAllocSettlInstType.trackObjects = 0;
  
  SwigClassTargetPartyID.klass = rb_define_class_under(mQuickfix, "TargetPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetPartyID, (void *) &SwigClassTargetPartyID);
  rb_define_alloc_func(SwigClassTargetPartyID.klass, _wrap_TargetPartyID_allocate);
  rb_define_method(SwigClassTargetPartyID.klass, "initialize", VALUEFUNC(_wrap_new_TargetPartyID), -1);
  SwigClassTargetPartyID.mark = 0;
  SwigClassTargetPartyID.destroy = (void (*)(void *)) free_FIX_TargetPartyID;
  SwigClassTargetPartyID.trackObjects = 0;
  
  SwigClassDerivativeStrikeCurrency.klass = rb_define_class_under(mQuickfix, "DerivativeStrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikeCurrency, (void *) &SwigClassDerivativeStrikeCurrency);
  rb_define_alloc_func(SwigClassDerivativeStrikeCurrency.klass, _wrap_DerivativeStrikeCurrency_allocate);
  rb_define_method(SwigClassDerivativeStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikeCurrency), -1);
  SwigClassDerivativeStrikeCurrency.mark = 0;
  SwigClassDerivativeStrikeCurrency.destroy = (void (*)(void *)) free_FIX_DerivativeStrikeCurrency;
  SwigClassDerivativeStrikeCurrency.trackObjects = 0;
  
  SwigClassStatsType.klass = rb_define_class_under(mQuickfix, "StatsType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StatsType, (void *) &SwigClassStatsType);
  rb_define_alloc_func(SwigClassStatsType.klass, _wrap_StatsType_allocate);
  rb_define_method(SwigClassStatsType.klass, "initialize", VALUEFUNC(_wrap_new_StatsType), -1);
  SwigClassStatsType.mark = 0;
  SwigClassStatsType.destroy = (void (*)(void *)) free_FIX_StatsType;
  SwigClassStatsType.trackObjects = 0;
  
  SwigClassApplExtID.klass = rb_define_class_under(mQuickfix, "ApplExtID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplExtID, (void *) &SwigClassApplExtID);
  rb_define_alloc_func(SwigClassApplExtID.klass, _wrap_ApplExtID_allocate);
  rb_define_method(SwigClassApplExtID.klass, "initialize", VALUEFUNC(_wrap_new_ApplExtID), -1);
  SwigClassApplExtID.mark = 0;
  SwigClassApplExtID.destroy = (void (*)(void *)) free_FIX_ApplExtID;
  SwigClassApplExtID.trackObjects = 0;
  
  SwigClassSettlementCycleNo.klass = rb_define_class_under(mQuickfix, "SettlementCycleNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlementCycleNo, (void *) &SwigClassSettlementCycleNo);
  rb_define_alloc_func(SwigClassSettlementCycleNo.klass, _wrap_SettlementCycleNo_allocate);
  rb_define_method(SwigClassSettlementCycleNo.klass, "initialize", VALUEFUNC(_wrap_new_SettlementCycleNo), -1);
  SwigClassSettlementCycleNo.mark = 0;
  SwigClassSettlementCycleNo.destroy = (void (*)(void *)) free_FIX_SettlementCycleNo;
  SwigClassSettlementCycleNo.trackObjects = 0;
  
  SwigClassUnderlyingStrikeCurrency.klass = rb_define_class_under(mQuickfix, "UnderlyingStrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStrikeCurrency, (void *) &SwigClassUnderlyingStrikeCurrency);
  rb_define_alloc_func(SwigClassUnderlyingStrikeCurrency.klass, _wrap_UnderlyingStrikeCurrency_allocate);
  rb_define_method(SwigClassUnderlyingStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStrikeCurrency), -1);
  SwigClassUnderlyingStrikeCurrency.mark = 0;
  SwigClassUnderlyingStrikeCurrency.destroy = (void (*)(void *)) free_FIX_UnderlyingStrikeCurrency;
  SwigClassUnderlyingStrikeCurrency.trackObjects = 0;
  
  SwigClassTradSesMode.klass = rb_define_class_under(mQuickfix, "TradSesMode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesMode, (void *) &SwigClassTradSesMode);
  rb_define_alloc_func(SwigClassTradSesMode.klass, _wrap_TradSesMode_allocate);
  rb_define_method(SwigClassTradSesMode.klass, "initialize", VALUEFUNC(_wrap_new_TradSesMode), -1);
  SwigClassTradSesMode.mark = 0;
  SwigClassTradSesMode.destroy = (void (*)(void *)) free_FIX_TradSesMode;
  SwigClassTradSesMode.trackObjects = 0;
  
  SwigClassSettlInstSource.klass = rb_define_class_under(mQuickfix, "SettlInstSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstSource, (void *) &SwigClassSettlInstSource);
  rb_define_alloc_func(SwigClassSettlInstSource.klass, _wrap_SettlInstSource_allocate);
  rb_define_method(SwigClassSettlInstSource.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstSource), -1);
  SwigClassSettlInstSource.mark = 0;
  SwigClassSettlInstSource.destroy = (void (*)(void *)) free_FIX_SettlInstSource;
  SwigClassSettlInstSource.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityDesc.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc, (void *) &SwigClassUnderlyingLegSecurityDesc);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityDesc.klass, _wrap_UnderlyingLegSecurityDesc_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityDesc), -1);
  SwigClassUnderlyingLegSecurityDesc.mark = 0;
  SwigClassUnderlyingLegSecurityDesc.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityDesc;
  SwigClassUnderlyingLegSecurityDesc.trackObjects = 0;
  
  SwigClassNoDerivativeInstrumentParties.klass = rb_define_class_under(mQuickfix, "NoDerivativeInstrumentParties", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeInstrumentParties, (void *) &SwigClassNoDerivativeInstrumentParties);
  rb_define_alloc_func(SwigClassNoDerivativeInstrumentParties.klass, _wrap_NoDerivativeInstrumentParties_allocate);
  rb_define_method(SwigClassNoDerivativeInstrumentParties.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeInstrumentParties), -1);
  SwigClassNoDerivativeInstrumentParties.mark = 0;
  SwigClassNoDerivativeInstrumentParties.destroy = (void (*)(void *)) free_FIX_NoDerivativeInstrumentParties;
  SwigClassNoDerivativeInstrumentParties.trackObjects = 0;
  
  SwigClassDerivativeEventTime.klass = rb_define_class_under(mQuickfix, "DerivativeEventTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventTime, (void *) &SwigClassDerivativeEventTime);
  rb_define_alloc_func(SwigClassDerivativeEventTime.klass, _wrap_DerivativeEventTime_allocate);
  rb_define_method(SwigClassDerivativeEventTime.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventTime), -1);
  SwigClassDerivativeEventTime.mark = 0;
  SwigClassDerivativeEventTime.destroy = (void (*)(void *)) free_FIX_DerivativeEventTime;
  SwigClassDerivativeEventTime.trackObjects = 0;
  
  SwigClassTickIncrement.klass = rb_define_class_under(mQuickfix, "TickIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TickIncrement, (void *) &SwigClassTickIncrement);
  rb_define_alloc_func(SwigClassTickIncrement.klass, _wrap_TickIncrement_allocate);
  rb_define_method(SwigClassTickIncrement.klass, "initialize", VALUEFUNC(_wrap_new_TickIncrement), -1);
  SwigClassTickIncrement.mark = 0;
  SwigClassTickIncrement.destroy = (void (*)(void *)) free_FIX_TickIncrement;
  SwigClassTickIncrement.trackObjects = 0;
  
  SwigClassUndlyInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyID, (void *) &SwigClassUndlyInstrumentPartyID);
  rb_define_alloc_func(SwigClassUndlyInstrumentPartyID.klass, _wrap_UndlyInstrumentPartyID_allocate);
  rb_define_method(SwigClassUndlyInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartyID), -1);
  SwigClassUndlyInstrumentPartyID.mark = 0;
  SwigClassUndlyInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartyID;
  SwigClassUndlyInstrumentPartyID.trackObjects = 0;
  
  SwigClassNoUndlyInstrumentParties.klass = rb_define_class_under(mQuickfix, "NoUndlyInstrumentParties", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUndlyInstrumentParties, (void *) &SwigClassNoUndlyInstrumentParties);
  rb_define_alloc_func(SwigClassNoUndlyInstrumentParties.klass, _wrap_NoUndlyInstrumentParties_allocate);
  rb_define_method(SwigClassNoUndlyInstrumentParties.klass, "initialize", VALUEFUNC(_wrap_new_NoUndlyInstrumentParties), -1);
  SwigClassNoUndlyInstrumentParties.mark = 0;
  SwigClassNoUndlyInstrumentParties.destroy = (void (*)(void *)) free_FIX_NoUndlyInstrumentParties;
  SwigClassNoUndlyInstrumentParties.trackObjects = 0;
  
  SwigClassExpType.klass = rb_define_class_under(mQuickfix, "ExpType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpType, (void *) &SwigClassExpType);
  rb_define_alloc_func(SwigClassExpType.klass, _wrap_ExpType_allocate);
  rb_define_method(SwigClassExpType.klass, "initialize", VALUEFUNC(_wrap_new_ExpType), -1);
  SwigClassExpType.mark = 0;
  SwigClassExpType.destroy = (void (*)(void *)) free_FIX_ExpType;
  SwigClassExpType.trackObjects = 0;
  
  SwigClassSecondaryClOrdID.klass = rb_define_class_under(mQuickfix, "SecondaryClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryClOrdID, (void *) &SwigClassSecondaryClOrdID);
  rb_define_alloc_func(SwigClassSecondaryClOrdID.klass, _wrap_SecondaryClOrdID_allocate);
  rb_define_method(SwigClassSecondaryClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryClOrdID), -1);
  SwigClassSecondaryClOrdID.mark = 0;
  SwigClassSecondaryClOrdID.destroy = (void (*)(void *)) free_FIX_SecondaryClOrdID;
  SwigClassSecondaryClOrdID.trackObjects = 0;
  
  SwigClassSettlInstTransType.klass = rb_define_class_under(mQuickfix, "SettlInstTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstTransType, (void *) &SwigClassSettlInstTransType);
  rb_define_alloc_func(SwigClassSettlInstTransType.klass, _wrap_SettlInstTransType_allocate);
  rb_define_method(SwigClassSettlInstTransType.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstTransType), -1);
  SwigClassSettlInstTransType.mark = 0;
  SwigClassSettlInstTransType.destroy = (void (*)(void *)) free_FIX_SettlInstTransType;
  SwigClassSettlInstTransType.trackObjects = 0;
  
  SwigClassSideComplianceID.klass = rb_define_class_under(mQuickfix, "SideComplianceID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideComplianceID, (void *) &SwigClassSideComplianceID);
  rb_define_alloc_func(SwigClassSideComplianceID.klass, _wrap_SideComplianceID_allocate);
  rb_define_method(SwigClassSideComplianceID.klass, "initialize", VALUEFUNC(_wrap_new_SideComplianceID), -1);
  SwigClassSideComplianceID.mark = 0;
  SwigClassSideComplianceID.destroy = (void (*)(void *)) free_FIX_SideComplianceID;
  SwigClassSideComplianceID.trackObjects = 0;
  
  SwigClassTradeRequestResult.klass = rb_define_class_under(mQuickfix, "TradeRequestResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestResult, (void *) &SwigClassTradeRequestResult);
  rb_define_alloc_func(SwigClassTradeRequestResult.klass, _wrap_TradeRequestResult_allocate);
  rb_define_method(SwigClassTradeRequestResult.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestResult), -1);
  SwigClassTradeRequestResult.mark = 0;
  SwigClassTradeRequestResult.destroy = (void (*)(void *)) free_FIX_TradeRequestResult;
  SwigClassTradeRequestResult.trackObjects = 0;
  
  SwigClassOrigPosReqRefID.klass = rb_define_class_under(mQuickfix, "OrigPosReqRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigPosReqRefID, (void *) &SwigClassOrigPosReqRefID);
  rb_define_alloc_func(SwigClassOrigPosReqRefID.klass, _wrap_OrigPosReqRefID_allocate);
  rb_define_method(SwigClassOrigPosReqRefID.klass, "initialize", VALUEFUNC(_wrap_new_OrigPosReqRefID), -1);
  SwigClassOrigPosReqRefID.mark = 0;
  SwigClassOrigPosReqRefID.destroy = (void (*)(void *)) free_FIX_OrigPosReqRefID;
  SwigClassOrigPosReqRefID.trackObjects = 0;
  
  SwigClassOrigCrossID.klass = rb_define_class_under(mQuickfix, "OrigCrossID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigCrossID, (void *) &SwigClassOrigCrossID);
  rb_define_alloc_func(SwigClassOrigCrossID.klass, _wrap_OrigCrossID_allocate);
  rb_define_method(SwigClassOrigCrossID.klass, "initialize", VALUEFUNC(_wrap_new_OrigCrossID), -1);
  SwigClassOrigCrossID.mark = 0;
  SwigClassOrigCrossID.destroy = (void (*)(void *)) free_FIX_OrigCrossID;
  SwigClassOrigCrossID.trackObjects = 0;
  
  SwigClassTradeInputSource.klass = rb_define_class_under(mQuickfix, "TradeInputSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeInputSource, (void *) &SwigClassTradeInputSource);
  rb_define_alloc_func(SwigClassTradeInputSource.klass, _wrap_TradeInputSource_allocate);
  rb_define_method(SwigClassTradeInputSource.klass, "initialize", VALUEFUNC(_wrap_new_TradeInputSource), -1);
  SwigClassTradeInputSource.mark = 0;
  SwigClassTradeInputSource.destroy = (void (*)(void *)) free_FIX_TradeInputSource;
  SwigClassTradeInputSource.trackObjects = 0;
  
  SwigClassOrderQty2.klass = rb_define_class_under(mQuickfix, "OrderQty2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderQty2, (void *) &SwigClassOrderQty2);
  rb_define_alloc_func(SwigClassOrderQty2.klass, _wrap_OrderQty2_allocate);
  rb_define_method(SwigClassOrderQty2.klass, "initialize", VALUEFUNC(_wrap_new_OrderQty2), -1);
  SwigClassOrderQty2.mark = 0;
  SwigClassOrderQty2.destroy = (void (*)(void *)) free_FIX_OrderQty2;
  SwigClassOrderQty2.trackObjects = 0;
  
  SwigClassTestMessageIndicator.klass = rb_define_class_under(mQuickfix, "TestMessageIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TestMessageIndicator, (void *) &SwigClassTestMessageIndicator);
  rb_define_alloc_func(SwigClassTestMessageIndicator.klass, _wrap_TestMessageIndicator_allocate);
  rb_define_method(SwigClassTestMessageIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TestMessageIndicator), -1);
  SwigClassTestMessageIndicator.mark = 0;
  SwigClassTestMessageIndicator.destroy = (void (*)(void *)) free_FIX_TestMessageIndicator;
  SwigClassTestMessageIndicator.trackObjects = 0;
  
  SwigClassDerivativeEventDate.klass = rb_define_class_under(mQuickfix, "DerivativeEventDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventDate, (void *) &SwigClassDerivativeEventDate);
  rb_define_alloc_func(SwigClassDerivativeEventDate.klass, _wrap_DerivativeEventDate_allocate);
  rb_define_method(SwigClassDerivativeEventDate.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventDate), -1);
  SwigClassDerivativeEventDate.mark = 0;
  SwigClassDerivativeEventDate.destroy = (void (*)(void *)) free_FIX_DerivativeEventDate;
  SwigClassDerivativeEventDate.trackObjects = 0;
  
  SwigClassSideGrossTradeAmt.klass = rb_define_class_under(mQuickfix, "SideGrossTradeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideGrossTradeAmt, (void *) &SwigClassSideGrossTradeAmt);
  rb_define_alloc_func(SwigClassSideGrossTradeAmt.klass, _wrap_SideGrossTradeAmt_allocate);
  rb_define_method(SwigClassSideGrossTradeAmt.klass, "initialize", VALUEFUNC(_wrap_new_SideGrossTradeAmt), -1);
  SwigClassSideGrossTradeAmt.mark = 0;
  SwigClassSideGrossTradeAmt.destroy = (void (*)(void *)) free_FIX_SideGrossTradeAmt;
  SwigClassSideGrossTradeAmt.trackObjects = 0;
  
  SwigClassPeggedPrice.klass = rb_define_class_under(mQuickfix, "PeggedPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PeggedPrice, (void *) &SwigClassPeggedPrice);
  rb_define_alloc_func(SwigClassPeggedPrice.klass, _wrap_PeggedPrice_allocate);
  rb_define_method(SwigClassPeggedPrice.klass, "initialize", VALUEFUNC(_wrap_new_PeggedPrice), -1);
  SwigClassPeggedPrice.mark = 0;
  SwigClassPeggedPrice.destroy = (void (*)(void *)) free_FIX_PeggedPrice;
  SwigClassPeggedPrice.trackObjects = 0;
  
  SwigClassExpirationCycle.klass = rb_define_class_under(mQuickfix, "ExpirationCycle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpirationCycle, (void *) &SwigClassExpirationCycle);
  rb_define_alloc_func(SwigClassExpirationCycle.klass, _wrap_ExpirationCycle_allocate);
  rb_define_method(SwigClassExpirationCycle.klass, "initialize", VALUEFUNC(_wrap_new_ExpirationCycle), -1);
  SwigClassExpirationCycle.mark = 0;
  SwigClassExpirationCycle.destroy = (void (*)(void *)) free_FIX_ExpirationCycle;
  SwigClassExpirationCycle.trackObjects = 0;
  
  SwigClassAllocCancReplaceReason.klass = rb_define_class_under(mQuickfix, "AllocCancReplaceReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocCancReplaceReason, (void *) &SwigClassAllocCancReplaceReason);
  rb_define_alloc_func(SwigClassAllocCancReplaceReason.klass, _wrap_AllocCancReplaceReason_allocate);
  rb_define_method(SwigClassAllocCancReplaceReason.klass, "initialize", VALUEFUNC(_wrap_new_AllocCancReplaceReason), -1);
  SwigClassAllocCancReplaceReason.mark = 0;
  SwigClassAllocCancReplaceReason.destroy = (void (*)(void *)) free_FIX_AllocCancReplaceReason;
  SwigClassAllocCancReplaceReason.trackObjects = 0;
  
  SwigClassCxlRejReason.klass = rb_define_class_under(mQuickfix, "CxlRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlRejReason, (void *) &SwigClassCxlRejReason);
  rb_define_alloc_func(SwigClassCxlRejReason.klass, _wrap_CxlRejReason_allocate);
  rb_define_method(SwigClassCxlRejReason.klass, "initialize", VALUEFUNC(_wrap_new_CxlRejReason), -1);
  SwigClassCxlRejReason.mark = 0;
  SwigClassCxlRejReason.destroy = (void (*)(void *)) free_FIX_CxlRejReason;
  SwigClassCxlRejReason.trackObjects = 0;
  
  SwigClassBeginString.klass = rb_define_class_under(mQuickfix, "BeginString", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BeginString, (void *) &SwigClassBeginString);
  rb_define_alloc_func(SwigClassBeginString.klass, _wrap_BeginString_allocate);
  rb_define_method(SwigClassBeginString.klass, "initialize", VALUEFUNC(_wrap_new_BeginString), -1);
  SwigClassBeginString.mark = 0;
  SwigClassBeginString.destroy = (void (*)(void *)) free_FIX_BeginString;
  SwigClassBeginString.trackObjects = 0;
  
  SwigClassDeliverToSubID.klass = rb_define_class_under(mQuickfix, "DeliverToSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliverToSubID, (void *) &SwigClassDeliverToSubID);
  rb_define_alloc_func(SwigClassDeliverToSubID.klass, _wrap_DeliverToSubID_allocate);
  rb_define_method(SwigClassDeliverToSubID.klass, "initialize", VALUEFUNC(_wrap_new_DeliverToSubID), -1);
  SwigClassDeliverToSubID.mark = 0;
  SwigClassDeliverToSubID.destroy = (void (*)(void *)) free_FIX_DeliverToSubID;
  SwigClassDeliverToSubID.trackObjects = 0;
  
  SwigClassLegPriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "LegPriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty, (void *) &SwigClassLegPriceUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassLegPriceUnitOfMeasureQty.klass, _wrap_LegPriceUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassLegPriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_LegPriceUnitOfMeasureQty), -1);
  SwigClassLegPriceUnitOfMeasureQty.mark = 0;
  SwigClassLegPriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_LegPriceUnitOfMeasureQty;
  SwigClassLegPriceUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassNoCollInquiryQualifier.klass = rb_define_class_under(mQuickfix, "NoCollInquiryQualifier", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoCollInquiryQualifier, (void *) &SwigClassNoCollInquiryQualifier);
  rb_define_alloc_func(SwigClassNoCollInquiryQualifier.klass, _wrap_NoCollInquiryQualifier_allocate);
  rb_define_method(SwigClassNoCollInquiryQualifier.klass, "initialize", VALUEFUNC(_wrap_new_NoCollInquiryQualifier), -1);
  SwigClassNoCollInquiryQualifier.mark = 0;
  SwigClassNoCollInquiryQualifier.destroy = (void (*)(void *)) free_FIX_NoCollInquiryQualifier;
  SwigClassNoCollInquiryQualifier.trackObjects = 0;
  
  SwigClassOfferPx.klass = rb_define_class_under(mQuickfix, "OfferPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferPx, (void *) &SwigClassOfferPx);
  rb_define_alloc_func(SwigClassOfferPx.klass, _wrap_OfferPx_allocate);
  rb_define_method(SwigClassOfferPx.klass, "initialize", VALUEFUNC(_wrap_new_OfferPx), -1);
  SwigClassOfferPx.mark = 0;
  SwigClassOfferPx.destroy = (void (*)(void *)) free_FIX_OfferPx;
  SwigClassOfferPx.trackObjects = 0;
  
  SwigClassTotalVolumeTradedDate.klass = rb_define_class_under(mQuickfix, "TotalVolumeTradedDate", ((swig_class *) SWIGTYPE_p_FIX__UtcDateField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalVolumeTradedDate, (void *) &SwigClassTotalVolumeTradedDate);
  rb_define_alloc_func(SwigClassTotalVolumeTradedDate.klass, _wrap_TotalVolumeTradedDate_allocate);
  rb_define_method(SwigClassTotalVolumeTradedDate.klass, "initialize", VALUEFUNC(_wrap_new_TotalVolumeTradedDate), -1);
  SwigClassTotalVolumeTradedDate.mark = 0;
  SwigClassTotalVolumeTradedDate.destroy = (void (*)(void *)) free_FIX_TotalVolumeTradedDate;
  SwigClassTotalVolumeTradedDate.trackObjects = 0;
  
  SwigClassNoContAmts.klass = rb_define_class_under(mQuickfix, "NoContAmts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoContAmts, (void *) &SwigClassNoContAmts);
  rb_define_alloc_func(SwigClassNoContAmts.klass, _wrap_NoContAmts_allocate);
  rb_define_method(SwigClassNoContAmts.klass, "initialize", VALUEFUNC(_wrap_new_NoContAmts), -1);
  SwigClassNoContAmts.mark = 0;
  SwigClassNoContAmts.destroy = (void (*)(void *)) free_FIX_NoContAmts;
  SwigClassNoContAmts.trackObjects = 0;
  
  SwigClassMinOfferSize.klass = rb_define_class_under(mQuickfix, "MinOfferSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinOfferSize, (void *) &SwigClassMinOfferSize);
  rb_define_alloc_func(SwigClassMinOfferSize.klass, _wrap_MinOfferSize_allocate);
  rb_define_method(SwigClassMinOfferSize.klass, "initialize", VALUEFUNC(_wrap_new_MinOfferSize), -1);
  SwigClassMinOfferSize.mark = 0;
  SwigClassMinOfferSize.destroy = (void (*)(void *)) free_FIX_MinOfferSize;
  SwigClassMinOfferSize.trackObjects = 0;
  
  SwigClassAvgParPx.klass = rb_define_class_under(mQuickfix, "AvgParPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgParPx, (void *) &SwigClassAvgParPx);
  rb_define_alloc_func(SwigClassAvgParPx.klass, _wrap_AvgParPx_allocate);
  rb_define_method(SwigClassAvgParPx.klass, "initialize", VALUEFUNC(_wrap_new_AvgParPx), -1);
  SwigClassAvgParPx.mark = 0;
  SwigClassAvgParPx.destroy = (void (*)(void *)) free_FIX_AvgParPx;
  SwigClassAvgParPx.trackObjects = 0;
  
  SwigClassLegFactor.klass = rb_define_class_under(mQuickfix, "LegFactor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegFactor, (void *) &SwigClassLegFactor);
  rb_define_alloc_func(SwigClassLegFactor.klass, _wrap_LegFactor_allocate);
  rb_define_method(SwigClassLegFactor.klass, "initialize", VALUEFUNC(_wrap_new_LegFactor), -1);
  SwigClassLegFactor.mark = 0;
  SwigClassLegFactor.destroy = (void (*)(void *)) free_FIX_LegFactor;
  SwigClassLegFactor.trackObjects = 0;
  
  SwigClassRespondentType.klass = rb_define_class_under(mQuickfix, "RespondentType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RespondentType, (void *) &SwigClassRespondentType);
  rb_define_alloc_func(SwigClassRespondentType.klass, _wrap_RespondentType_allocate);
  rb_define_method(SwigClassRespondentType.klass, "initialize", VALUEFUNC(_wrap_new_RespondentType), -1);
  SwigClassRespondentType.mark = 0;
  SwigClassRespondentType.destroy = (void (*)(void *)) free_FIX_RespondentType;
  SwigClassRespondentType.trackObjects = 0;
  
  SwigClassDisplayLowQty.klass = rb_define_class_under(mQuickfix, "DisplayLowQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayLowQty, (void *) &SwigClassDisplayLowQty);
  rb_define_alloc_func(SwigClassDisplayLowQty.klass, _wrap_DisplayLowQty_allocate);
  rb_define_method(SwigClassDisplayLowQty.klass, "initialize", VALUEFUNC(_wrap_new_DisplayLowQty), -1);
  SwigClassDisplayLowQty.mark = 0;
  SwigClassDisplayLowQty.destroy = (void (*)(void *)) free_FIX_DisplayLowQty;
  SwigClassDisplayLowQty.trackObjects = 0;
  
  SwigClassDKReason.klass = rb_define_class_under(mQuickfix, "DKReason", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DKReason, (void *) &SwigClassDKReason);
  rb_define_alloc_func(SwigClassDKReason.klass, _wrap_DKReason_allocate);
  rb_define_method(SwigClassDKReason.klass, "initialize", VALUEFUNC(_wrap_new_DKReason), -1);
  SwigClassDKReason.mark = 0;
  SwigClassDKReason.destroy = (void (*)(void *)) free_FIX_DKReason;
  SwigClassDKReason.trackObjects = 0;
  
  SwigClassBenchmarkPrice.klass = rb_define_class_under(mQuickfix, "BenchmarkPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkPrice, (void *) &SwigClassBenchmarkPrice);
  rb_define_alloc_func(SwigClassBenchmarkPrice.klass, _wrap_BenchmarkPrice_allocate);
  rb_define_method(SwigClassBenchmarkPrice.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkPrice), -1);
  SwigClassBenchmarkPrice.mark = 0;
  SwigClassBenchmarkPrice.destroy = (void (*)(void *)) free_FIX_BenchmarkPrice;
  SwigClassBenchmarkPrice.trackObjects = 0;
  
  SwigClassListID.klass = rb_define_class_under(mQuickfix, "ListID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListID, (void *) &SwigClassListID);
  rb_define_alloc_func(SwigClassListID.klass, _wrap_ListID_allocate);
  rb_define_method(SwigClassListID.klass, "initialize", VALUEFUNC(_wrap_new_ListID), -1);
  SwigClassListID.mark = 0;
  SwigClassListID.destroy = (void (*)(void *)) free_FIX_ListID;
  SwigClassListID.trackObjects = 0;
  
  SwigClassLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "LegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityAltID, (void *) &SwigClassLegSecurityAltID);
  rb_define_alloc_func(SwigClassLegSecurityAltID.klass, _wrap_LegSecurityAltID_allocate);
  rb_define_method(SwigClassLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityAltID), -1);
  SwigClassLegSecurityAltID.mark = 0;
  SwigClassLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_LegSecurityAltID;
  SwigClassLegSecurityAltID.trackObjects = 0;
  
  SwigClassPositionEffect.klass = rb_define_class_under(mQuickfix, "PositionEffect", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PositionEffect, (void *) &SwigClassPositionEffect);
  rb_define_alloc_func(SwigClassPositionEffect.klass, _wrap_PositionEffect_allocate);
  rb_define_method(SwigClassPositionEffect.klass, "initialize", VALUEFUNC(_wrap_new_PositionEffect), -1);
  SwigClassPositionEffect.mark = 0;
  SwigClassPositionEffect.destroy = (void (*)(void *)) free_FIX_PositionEffect;
  SwigClassPositionEffect.trackObjects = 0;
  
  SwigClassTriggerAction.klass = rb_define_class_under(mQuickfix, "TriggerAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerAction, (void *) &SwigClassTriggerAction);
  rb_define_alloc_func(SwigClassTriggerAction.klass, _wrap_TriggerAction_allocate);
  rb_define_method(SwigClassTriggerAction.klass, "initialize", VALUEFUNC(_wrap_new_TriggerAction), -1);
  SwigClassTriggerAction.mark = 0;
  SwigClassTriggerAction.destroy = (void (*)(void *)) free_FIX_TriggerAction;
  SwigClassTriggerAction.trackObjects = 0;
  
  SwigClassRefOrderID.klass = rb_define_class_under(mQuickfix, "RefOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefOrderID, (void *) &SwigClassRefOrderID);
  rb_define_alloc_func(SwigClassRefOrderID.klass, _wrap_RefOrderID_allocate);
  rb_define_method(SwigClassRefOrderID.klass, "initialize", VALUEFUNC(_wrap_new_RefOrderID), -1);
  SwigClassRefOrderID.mark = 0;
  SwigClassRefOrderID.destroy = (void (*)(void *)) free_FIX_RefOrderID;
  SwigClassRefOrderID.trackObjects = 0;
  
  SwigClassClearingInstruction.klass = rb_define_class_under(mQuickfix, "ClearingInstruction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingInstruction, (void *) &SwigClassClearingInstruction);
  rb_define_alloc_func(SwigClassClearingInstruction.klass, _wrap_ClearingInstruction_allocate);
  rb_define_method(SwigClassClearingInstruction.klass, "initialize", VALUEFUNC(_wrap_new_ClearingInstruction), -1);
  SwigClassClearingInstruction.mark = 0;
  SwigClassClearingInstruction.destroy = (void (*)(void *)) free_FIX_ClearingInstruction;
  SwigClassClearingInstruction.trackObjects = 0;
  
  SwigClassSettlInstCode.klass = rb_define_class_under(mQuickfix, "SettlInstCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstCode, (void *) &SwigClassSettlInstCode);
  rb_define_alloc_func(SwigClassSettlInstCode.klass, _wrap_SettlInstCode_allocate);
  rb_define_method(SwigClassSettlInstCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstCode), -1);
  SwigClassSettlInstCode.mark = 0;
  SwigClassSettlInstCode.destroy = (void (*)(void *)) free_FIX_SettlInstCode;
  SwigClassSettlInstCode.trackObjects = 0;
  
  SwigClassNumDaysInterest.klass = rb_define_class_under(mQuickfix, "NumDaysInterest", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumDaysInterest, (void *) &SwigClassNumDaysInterest);
  rb_define_alloc_func(SwigClassNumDaysInterest.klass, _wrap_NumDaysInterest_allocate);
  rb_define_method(SwigClassNumDaysInterest.klass, "initialize", VALUEFUNC(_wrap_new_NumDaysInterest), -1);
  SwigClassNumDaysInterest.mark = 0;
  SwigClassNumDaysInterest.destroy = (void (*)(void *)) free_FIX_NumDaysInterest;
  SwigClassNumDaysInterest.trackObjects = 0;
  
  SwigClassOpenCloseSettlFlag.klass = rb_define_class_under(mQuickfix, "OpenCloseSettlFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenCloseSettlFlag, (void *) &SwigClassOpenCloseSettlFlag);
  rb_define_alloc_func(SwigClassOpenCloseSettlFlag.klass, _wrap_OpenCloseSettlFlag_allocate);
  rb_define_method(SwigClassOpenCloseSettlFlag.klass, "initialize", VALUEFUNC(_wrap_new_OpenCloseSettlFlag), -1);
  SwigClassOpenCloseSettlFlag.mark = 0;
  SwigClassOpenCloseSettlFlag.destroy = (void (*)(void *)) free_FIX_OpenCloseSettlFlag;
  SwigClassOpenCloseSettlFlag.trackObjects = 0;
  
  SwigClassNoComplexEventDates.klass = rb_define_class_under(mQuickfix, "NoComplexEventDates", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoComplexEventDates, (void *) &SwigClassNoComplexEventDates);
  rb_define_alloc_func(SwigClassNoComplexEventDates.klass, _wrap_NoComplexEventDates_allocate);
  rb_define_method(SwigClassNoComplexEventDates.klass, "initialize", VALUEFUNC(_wrap_new_NoComplexEventDates), -1);
  SwigClassNoComplexEventDates.mark = 0;
  SwigClassNoComplexEventDates.destroy = (void (*)(void *)) free_FIX_NoComplexEventDates;
  SwigClassNoComplexEventDates.trackObjects = 0;
  
  SwigClassDerivativeEncodedIssuerLen.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen, (void *) &SwigClassDerivativeEncodedIssuerLen);
  rb_define_alloc_func(SwigClassDerivativeEncodedIssuerLen.klass, _wrap_DerivativeEncodedIssuerLen_allocate);
  rb_define_method(SwigClassDerivativeEncodedIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedIssuerLen), -1);
  SwigClassDerivativeEncodedIssuerLen.mark = 0;
  SwigClassDerivativeEncodedIssuerLen.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedIssuerLen;
  SwigClassDerivativeEncodedIssuerLen.trackObjects = 0;
  
  SwigClassStrikeMultiplier.klass = rb_define_class_under(mQuickfix, "StrikeMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeMultiplier, (void *) &SwigClassStrikeMultiplier);
  rb_define_alloc_func(SwigClassStrikeMultiplier.klass, _wrap_StrikeMultiplier_allocate);
  rb_define_method(SwigClassStrikeMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_StrikeMultiplier), -1);
  SwigClassStrikeMultiplier.mark = 0;
  SwigClassStrikeMultiplier.destroy = (void (*)(void *)) free_FIX_StrikeMultiplier;
  SwigClassStrikeMultiplier.trackObjects = 0;
  
  SwigClassDiscretionMoveType.klass = rb_define_class_under(mQuickfix, "DiscretionMoveType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionMoveType, (void *) &SwigClassDiscretionMoveType);
  rb_define_alloc_func(SwigClassDiscretionMoveType.klass, _wrap_DiscretionMoveType_allocate);
  rb_define_method(SwigClassDiscretionMoveType.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionMoveType), -1);
  SwigClassDiscretionMoveType.mark = 0;
  SwigClassDiscretionMoveType.destroy = (void (*)(void *)) free_FIX_DiscretionMoveType;
  SwigClassDiscretionMoveType.trackObjects = 0;
  
  SwigClassListNoOrds.klass = rb_define_class_under(mQuickfix, "ListNoOrds", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListNoOrds, (void *) &SwigClassListNoOrds);
  rb_define_alloc_func(SwigClassListNoOrds.klass, _wrap_ListNoOrds_allocate);
  rb_define_method(SwigClassListNoOrds.klass, "initialize", VALUEFUNC(_wrap_new_ListNoOrds), -1);
  SwigClassListNoOrds.mark = 0;
  SwigClassListNoOrds.destroy = (void (*)(void *)) free_FIX_ListNoOrds;
  SwigClassListNoOrds.trackObjects = 0;
  
  SwigClassPegSymbol.klass = rb_define_class_under(mQuickfix, "PegSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSymbol, (void *) &SwigClassPegSymbol);
  rb_define_alloc_func(SwigClassPegSymbol.klass, _wrap_PegSymbol_allocate);
  rb_define_method(SwigClassPegSymbol.klass, "initialize", VALUEFUNC(_wrap_new_PegSymbol), -1);
  SwigClassPegSymbol.mark = 0;
  SwigClassPegSymbol.destroy = (void (*)(void *)) free_FIX_PegSymbol;
  SwigClassPegSymbol.trackObjects = 0;
  
  SwigClassDayAvgPx.klass = rb_define_class_under(mQuickfix, "DayAvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayAvgPx, (void *) &SwigClassDayAvgPx);
  rb_define_alloc_func(SwigClassDayAvgPx.klass, _wrap_DayAvgPx_allocate);
  rb_define_method(SwigClassDayAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_DayAvgPx), -1);
  SwigClassDayAvgPx.mark = 0;
  SwigClassDayAvgPx.destroy = (void (*)(void *)) free_FIX_DayAvgPx;
  SwigClassDayAvgPx.trackObjects = 0;
  
  SwigClassHeadline.klass = rb_define_class_under(mQuickfix, "Headline", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Headline, (void *) &SwigClassHeadline);
  rb_define_alloc_func(SwigClassHeadline.klass, _wrap_Headline_allocate);
  rb_define_method(SwigClassHeadline.klass, "initialize", VALUEFUNC(_wrap_new_Headline), -1);
  SwigClassHeadline.mark = 0;
  SwigClassHeadline.destroy = (void (*)(void *)) free_FIX_Headline;
  SwigClassHeadline.trackObjects = 0;
  
  SwigClassNestedPartySubID.klass = rb_define_class_under(mQuickfix, "NestedPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartySubID, (void *) &SwigClassNestedPartySubID);
  rb_define_alloc_func(SwigClassNestedPartySubID.klass, _wrap_NestedPartySubID_allocate);
  rb_define_method(SwigClassNestedPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartySubID), -1);
  SwigClassNestedPartySubID.mark = 0;
  SwigClassNestedPartySubID.destroy = (void (*)(void *)) free_FIX_NestedPartySubID;
  SwigClassNestedPartySubID.trackObjects = 0;
  
  SwigClassCardIssNo.klass = rb_define_class_under(mQuickfix, "CardIssNo", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardIssNo, (void *) &SwigClassCardIssNo);
  rb_define_alloc_func(SwigClassCardIssNo.klass, _wrap_CardIssNo_allocate);
  rb_define_method(SwigClassCardIssNo.klass, "initialize", VALUEFUNC(_wrap_new_CardIssNo), -1);
  SwigClassCardIssNo.mark = 0;
  SwigClassCardIssNo.destroy = (void (*)(void *)) free_FIX_CardIssNo;
  SwigClassCardIssNo.trackObjects = 0;
  
  SwigClassOptAttribute.klass = rb_define_class_under(mQuickfix, "OptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptAttribute, (void *) &SwigClassOptAttribute);
  rb_define_alloc_func(SwigClassOptAttribute.klass, _wrap_OptAttribute_allocate);
  rb_define_method(SwigClassOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_OptAttribute), -1);
  SwigClassOptAttribute.mark = 0;
  SwigClassOptAttribute.destroy = (void (*)(void *)) free_FIX_OptAttribute;
  SwigClassOptAttribute.trackObjects = 0;
  
  SwigClassLastForwardPoints2.klass = rb_define_class_under(mQuickfix, "LastForwardPoints2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastForwardPoints2, (void *) &SwigClassLastForwardPoints2);
  rb_define_alloc_func(SwigClassLastForwardPoints2.klass, _wrap_LastForwardPoints2_allocate);
  rb_define_method(SwigClassLastForwardPoints2.klass, "initialize", VALUEFUNC(_wrap_new_LastForwardPoints2), -1);
  SwigClassLastForwardPoints2.mark = 0;
  SwigClassLastForwardPoints2.destroy = (void (*)(void *)) free_FIX_LastForwardPoints2;
  SwigClassLastForwardPoints2.trackObjects = 0;
  
  SwigClassMDUpdateType.klass = rb_define_class_under(mQuickfix, "MDUpdateType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDUpdateType, (void *) &SwigClassMDUpdateType);
  rb_define_alloc_func(SwigClassMDUpdateType.klass, _wrap_MDUpdateType_allocate);
  rb_define_method(SwigClassMDUpdateType.klass, "initialize", VALUEFUNC(_wrap_new_MDUpdateType), -1);
  SwigClassMDUpdateType.mark = 0;
  SwigClassMDUpdateType.destroy = (void (*)(void *)) free_FIX_MDUpdateType;
  SwigClassMDUpdateType.trackObjects = 0;
  
  SwigClassTickDirection.klass = rb_define_class_under(mQuickfix, "TickDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TickDirection, (void *) &SwigClassTickDirection);
  rb_define_alloc_func(SwigClassTickDirection.klass, _wrap_TickDirection_allocate);
  rb_define_method(SwigClassTickDirection.klass, "initialize", VALUEFUNC(_wrap_new_TickDirection), -1);
  SwigClassTickDirection.mark = 0;
  SwigClassTickDirection.destroy = (void (*)(void *)) free_FIX_TickDirection;
  SwigClassTickDirection.trackObjects = 0;
  
  SwigClassLegRedemptionDate.klass = rb_define_class_under(mQuickfix, "LegRedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRedemptionDate, (void *) &SwigClassLegRedemptionDate);
  rb_define_alloc_func(SwigClassLegRedemptionDate.klass, _wrap_LegRedemptionDate_allocate);
  rb_define_method(SwigClassLegRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_LegRedemptionDate), -1);
  SwigClassLegRedemptionDate.mark = 0;
  SwigClassLegRedemptionDate.destroy = (void (*)(void *)) free_FIX_LegRedemptionDate;
  SwigClassLegRedemptionDate.trackObjects = 0;
  
  SwigClassStrikePrice.klass = rb_define_class_under(mQuickfix, "StrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePrice, (void *) &SwigClassStrikePrice);
  rb_define_alloc_func(SwigClassStrikePrice.klass, _wrap_StrikePrice_allocate);
  rb_define_method(SwigClassStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_StrikePrice), -1);
  SwigClassStrikePrice.mark = 0;
  SwigClassStrikePrice.destroy = (void (*)(void *)) free_FIX_StrikePrice;
  SwigClassStrikePrice.trackObjects = 0;
  
  SwigClassEncodedIssuer.klass = rb_define_class_under(mQuickfix, "EncodedIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedIssuer, (void *) &SwigClassEncodedIssuer);
  rb_define_alloc_func(SwigClassEncodedIssuer.klass, _wrap_EncodedIssuer_allocate);
  rb_define_method(SwigClassEncodedIssuer.klass, "initialize", VALUEFUNC(_wrap_new_EncodedIssuer), -1);
  SwigClassEncodedIssuer.mark = 0;
  SwigClassEncodedIssuer.destroy = (void (*)(void *)) free_FIX_EncodedIssuer;
  SwigClassEncodedIssuer.trackObjects = 0;
  
  SwigClassYieldType.klass = rb_define_class_under(mQuickfix, "YieldType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldType, (void *) &SwigClassYieldType);
  rb_define_alloc_func(SwigClassYieldType.klass, _wrap_YieldType_allocate);
  rb_define_method(SwigClassYieldType.klass, "initialize", VALUEFUNC(_wrap_new_YieldType), -1);
  SwigClassYieldType.mark = 0;
  SwigClassYieldType.destroy = (void (*)(void *)) free_FIX_YieldType;
  SwigClassYieldType.trackObjects = 0;
  
  SwigClassTradingReferencePrice.klass = rb_define_class_under(mQuickfix, "TradingReferencePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingReferencePrice, (void *) &SwigClassTradingReferencePrice);
  rb_define_alloc_func(SwigClassTradingReferencePrice.klass, _wrap_TradingReferencePrice_allocate);
  rb_define_method(SwigClassTradingReferencePrice.klass, "initialize", VALUEFUNC(_wrap_new_TradingReferencePrice), -1);
  SwigClassTradingReferencePrice.mark = 0;
  SwigClassTradingReferencePrice.destroy = (void (*)(void *)) free_FIX_TradingReferencePrice;
  SwigClassTradingReferencePrice.trackObjects = 0;
  
  SwigClassMDEntrySpotRate.klass = rb_define_class_under(mQuickfix, "MDEntrySpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntrySpotRate, (void *) &SwigClassMDEntrySpotRate);
  rb_define_alloc_func(SwigClassMDEntrySpotRate.klass, _wrap_MDEntrySpotRate_allocate);
  rb_define_method(SwigClassMDEntrySpotRate.klass, "initialize", VALUEFUNC(_wrap_new_MDEntrySpotRate), -1);
  SwigClassMDEntrySpotRate.mark = 0;
  SwigClassMDEntrySpotRate.destroy = (void (*)(void *)) free_FIX_MDEntrySpotRate;
  SwigClassMDEntrySpotRate.trackObjects = 0;
  
  SwigClassParticipationRate.klass = rb_define_class_under(mQuickfix, "ParticipationRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ParticipationRate, (void *) &SwigClassParticipationRate);
  rb_define_alloc_func(SwigClassParticipationRate.klass, _wrap_ParticipationRate_allocate);
  rb_define_method(SwigClassParticipationRate.klass, "initialize", VALUEFUNC(_wrap_new_ParticipationRate), -1);
  SwigClassParticipationRate.mark = 0;
  SwigClassParticipationRate.destroy = (void (*)(void *)) free_FIX_ParticipationRate;
  SwigClassParticipationRate.trackObjects = 0;
  
  SwigClassPegScope.klass = rb_define_class_under(mQuickfix, "PegScope", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegScope, (void *) &SwigClassPegScope);
  rb_define_alloc_func(SwigClassPegScope.klass, _wrap_PegScope_allocate);
  rb_define_method(SwigClassPegScope.klass, "initialize", VALUEFUNC(_wrap_new_PegScope), -1);
  SwigClassPegScope.mark = 0;
  SwigClassPegScope.destroy = (void (*)(void *)) free_FIX_PegScope;
  SwigClassPegScope.trackObjects = 0;
  
  SwigClassInterestAtMaturity.klass = rb_define_class_under(mQuickfix, "InterestAtMaturity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InterestAtMaturity, (void *) &SwigClassInterestAtMaturity);
  rb_define_alloc_func(SwigClassInterestAtMaturity.klass, _wrap_InterestAtMaturity_allocate);
  rb_define_method(SwigClassInterestAtMaturity.klass, "initialize", VALUEFUNC(_wrap_new_InterestAtMaturity), -1);
  SwigClassInterestAtMaturity.mark = 0;
  SwigClassInterestAtMaturity.destroy = (void (*)(void *)) free_FIX_InterestAtMaturity;
  SwigClassInterestAtMaturity.trackObjects = 0;
  
  SwigClassLegIndividualAllocID.klass = rb_define_class_under(mQuickfix, "LegIndividualAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIndividualAllocID, (void *) &SwigClassLegIndividualAllocID);
  rb_define_alloc_func(SwigClassLegIndividualAllocID.klass, _wrap_LegIndividualAllocID_allocate);
  rb_define_method(SwigClassLegIndividualAllocID.klass, "initialize", VALUEFUNC(_wrap_new_LegIndividualAllocID), -1);
  SwigClassLegIndividualAllocID.mark = 0;
  SwigClassLegIndividualAllocID.destroy = (void (*)(void *)) free_FIX_LegIndividualAllocID;
  SwigClassLegIndividualAllocID.trackObjects = 0;
  
  SwigClassAllowableOneSidednessValue.klass = rb_define_class_under(mQuickfix, "AllowableOneSidednessValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllowableOneSidednessValue, (void *) &SwigClassAllowableOneSidednessValue);
  rb_define_alloc_func(SwigClassAllowableOneSidednessValue.klass, _wrap_AllowableOneSidednessValue_allocate);
  rb_define_method(SwigClassAllowableOneSidednessValue.klass, "initialize", VALUEFUNC(_wrap_new_AllowableOneSidednessValue), -1);
  SwigClassAllowableOneSidednessValue.mark = 0;
  SwigClassAllowableOneSidednessValue.destroy = (void (*)(void *)) free_FIX_AllowableOneSidednessValue;
  SwigClassAllowableOneSidednessValue.trackObjects = 0;
  
  SwigClassCashSettlAgentName.klass = rb_define_class_under(mQuickfix, "CashSettlAgentName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentName, (void *) &SwigClassCashSettlAgentName);
  rb_define_alloc_func(SwigClassCashSettlAgentName.klass, _wrap_CashSettlAgentName_allocate);
  rb_define_method(SwigClassCashSettlAgentName.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentName), -1);
  SwigClassCashSettlAgentName.mark = 0;
  SwigClassCashSettlAgentName.destroy = (void (*)(void *)) free_FIX_CashSettlAgentName;
  SwigClassCashSettlAgentName.trackObjects = 0;
  
  SwigClassContraTradeQty.klass = rb_define_class_under(mQuickfix, "ContraTradeQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraTradeQty, (void *) &SwigClassContraTradeQty);
  rb_define_alloc_func(SwigClassContraTradeQty.klass, _wrap_ContraTradeQty_allocate);
  rb_define_method(SwigClassContraTradeQty.klass, "initialize", VALUEFUNC(_wrap_new_ContraTradeQty), -1);
  SwigClassContraTradeQty.mark = 0;
  SwigClassContraTradeQty.destroy = (void (*)(void *)) free_FIX_ContraTradeQty;
  SwigClassContraTradeQty.trackObjects = 0;
  
  SwigClassLegMaturityTime.klass = rb_define_class_under(mQuickfix, "LegMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegMaturityTime, (void *) &SwigClassLegMaturityTime);
  rb_define_alloc_func(SwigClassLegMaturityTime.klass, _wrap_LegMaturityTime_allocate);
  rb_define_method(SwigClassLegMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_LegMaturityTime), -1);
  SwigClassLegMaturityTime.mark = 0;
  SwigClassLegMaturityTime.destroy = (void (*)(void *)) free_FIX_LegMaturityTime;
  SwigClassLegMaturityTime.trackObjects = 0;
  
  SwigClassSettlDeliveryType.klass = rb_define_class_under(mQuickfix, "SettlDeliveryType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDeliveryType, (void *) &SwigClassSettlDeliveryType);
  rb_define_alloc_func(SwigClassSettlDeliveryType.klass, _wrap_SettlDeliveryType_allocate);
  rb_define_method(SwigClassSettlDeliveryType.klass, "initialize", VALUEFUNC(_wrap_new_SettlDeliveryType), -1);
  SwigClassSettlDeliveryType.mark = 0;
  SwigClassSettlDeliveryType.destroy = (void (*)(void *)) free_FIX_SettlDeliveryType;
  SwigClassSettlDeliveryType.trackObjects = 0;
  
  SwigClassSecondaryPriceLimitType.klass = rb_define_class_under(mQuickfix, "SecondaryPriceLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryPriceLimitType, (void *) &SwigClassSecondaryPriceLimitType);
  rb_define_alloc_func(SwigClassSecondaryPriceLimitType.klass, _wrap_SecondaryPriceLimitType_allocate);
  rb_define_method(SwigClassSecondaryPriceLimitType.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryPriceLimitType), -1);
  SwigClassSecondaryPriceLimitType.mark = 0;
  SwigClassSecondaryPriceLimitType.destroy = (void (*)(void *)) free_FIX_SecondaryPriceLimitType;
  SwigClassSecondaryPriceLimitType.trackObjects = 0;
  
  SwigClassMidPx.klass = rb_define_class_under(mQuickfix, "MidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MidPx, (void *) &SwigClassMidPx);
  rb_define_alloc_func(SwigClassMidPx.klass, _wrap_MidPx_allocate);
  rb_define_method(SwigClassMidPx.klass, "initialize", VALUEFUNC(_wrap_new_MidPx), -1);
  SwigClassMidPx.mark = 0;
  SwigClassMidPx.destroy = (void (*)(void *)) free_FIX_MidPx;
  SwigClassMidPx.trackObjects = 0;
  
  SwigClassAvgPx.klass = rb_define_class_under(mQuickfix, "AvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPx, (void *) &SwigClassAvgPx);
  rb_define_alloc_func(SwigClassAvgPx.klass, _wrap_AvgPx_allocate);
  rb_define_method(SwigClassAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_AvgPx), -1);
  SwigClassAvgPx.mark = 0;
  SwigClassAvgPx.destroy = (void (*)(void *)) free_FIX_AvgPx;
  SwigClassAvgPx.trackObjects = 0;
  
  SwigClassDiscretionLimitType.klass = rb_define_class_under(mQuickfix, "DiscretionLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionLimitType, (void *) &SwigClassDiscretionLimitType);
  rb_define_alloc_func(SwigClassDiscretionLimitType.klass, _wrap_DiscretionLimitType_allocate);
  rb_define_method(SwigClassDiscretionLimitType.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionLimitType), -1);
  SwigClassDiscretionLimitType.mark = 0;
  SwigClassDiscretionLimitType.destroy = (void (*)(void *)) free_FIX_DiscretionLimitType;
  SwigClassDiscretionLimitType.trackObjects = 0;
  
  SwigClassStrikeTime.klass = rb_define_class_under(mQuickfix, "StrikeTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeTime, (void *) &SwigClassStrikeTime);
  rb_define_alloc_func(SwigClassStrikeTime.klass, _wrap_StrikeTime_allocate);
  rb_define_method(SwigClassStrikeTime.klass, "initialize", VALUEFUNC(_wrap_new_StrikeTime), -1);
  SwigClassStrikeTime.mark = 0;
  SwigClassStrikeTime.destroy = (void (*)(void *)) free_FIX_StrikeTime;
  SwigClassStrikeTime.trackObjects = 0;
  
  SwigClassSettlSessSubID.klass = rb_define_class_under(mQuickfix, "SettlSessSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlSessSubID, (void *) &SwigClassSettlSessSubID);
  rb_define_alloc_func(SwigClassSettlSessSubID.klass, _wrap_SettlSessSubID_allocate);
  rb_define_method(SwigClassSettlSessSubID.klass, "initialize", VALUEFUNC(_wrap_new_SettlSessSubID), -1);
  SwigClassSettlSessSubID.mark = 0;
  SwigClassSettlSessSubID.destroy = (void (*)(void *)) free_FIX_SettlSessSubID;
  SwigClassSettlSessSubID.trackObjects = 0;
  
  SwigClassMailingDtls.klass = rb_define_class_under(mQuickfix, "MailingDtls", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MailingDtls, (void *) &SwigClassMailingDtls);
  rb_define_alloc_func(SwigClassMailingDtls.klass, _wrap_MailingDtls_allocate);
  rb_define_method(SwigClassMailingDtls.klass, "initialize", VALUEFUNC(_wrap_new_MailingDtls), -1);
  SwigClassMailingDtls.mark = 0;
  SwigClassMailingDtls.destroy = (void (*)(void *)) free_FIX_MailingDtls;
  SwigClassMailingDtls.trackObjects = 0;
  
  SwigClassBidID.klass = rb_define_class_under(mQuickfix, "BidID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidID, (void *) &SwigClassBidID);
  rb_define_alloc_func(SwigClassBidID.klass, _wrap_BidID_allocate);
  rb_define_method(SwigClassBidID.klass, "initialize", VALUEFUNC(_wrap_new_BidID), -1);
  SwigClassBidID.mark = 0;
  SwigClassBidID.destroy = (void (*)(void *)) free_FIX_BidID;
  SwigClassBidID.trackObjects = 0;
  
  SwigClassExerciseMethod.klass = rb_define_class_under(mQuickfix, "ExerciseMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExerciseMethod, (void *) &SwigClassExerciseMethod);
  rb_define_alloc_func(SwigClassExerciseMethod.klass, _wrap_ExerciseMethod_allocate);
  rb_define_method(SwigClassExerciseMethod.klass, "initialize", VALUEFUNC(_wrap_new_ExerciseMethod), -1);
  SwigClassExerciseMethod.mark = 0;
  SwigClassExerciseMethod.destroy = (void (*)(void *)) free_FIX_ExerciseMethod;
  SwigClassExerciseMethod.trackObjects = 0;
  
  SwigClassCommCurrency.klass = rb_define_class_under(mQuickfix, "CommCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CommCurrency, (void *) &SwigClassCommCurrency);
  rb_define_alloc_func(SwigClassCommCurrency.klass, _wrap_CommCurrency_allocate);
  rb_define_method(SwigClassCommCurrency.klass, "initialize", VALUEFUNC(_wrap_new_CommCurrency), -1);
  SwigClassCommCurrency.mark = 0;
  SwigClassCommCurrency.destroy = (void (*)(void *)) free_FIX_CommCurrency;
  SwigClassCommCurrency.trackObjects = 0;
  
  SwigClassNoSettlOblig.klass = rb_define_class_under(mQuickfix, "NoSettlOblig", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlOblig, (void *) &SwigClassNoSettlOblig);
  rb_define_alloc_func(SwigClassNoSettlOblig.klass, _wrap_NoSettlOblig_allocate);
  rb_define_method(SwigClassNoSettlOblig.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlOblig), -1);
  SwigClassNoSettlOblig.mark = 0;
  SwigClassNoSettlOblig.destroy = (void (*)(void *)) free_FIX_NoSettlOblig;
  SwigClassNoSettlOblig.trackObjects = 0;
  
  SwigClassMaxPriceVariation.klass = rb_define_class_under(mQuickfix, "MaxPriceVariation", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxPriceVariation, (void *) &SwigClassMaxPriceVariation);
  rb_define_alloc_func(SwigClassMaxPriceVariation.klass, _wrap_MaxPriceVariation_allocate);
  rb_define_method(SwigClassMaxPriceVariation.klass, "initialize", VALUEFUNC(_wrap_new_MaxPriceVariation), -1);
  SwigClassMaxPriceVariation.mark = 0;
  SwigClassMaxPriceVariation.destroy = (void (*)(void *)) free_FIX_MaxPriceVariation;
  SwigClassMaxPriceVariation.trackObjects = 0;
  
  SwigClassWorkingIndicator.klass = rb_define_class_under(mQuickfix, "WorkingIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__WorkingIndicator, (void *) &SwigClassWorkingIndicator);
  rb_define_alloc_func(SwigClassWorkingIndicator.klass, _wrap_WorkingIndicator_allocate);
  rb_define_method(SwigClassWorkingIndicator.klass, "initialize", VALUEFUNC(_wrap_new_WorkingIndicator), -1);
  SwigClassWorkingIndicator.mark = 0;
  SwigClassWorkingIndicator.destroy = (void (*)(void *)) free_FIX_WorkingIndicator;
  SwigClassWorkingIndicator.trackObjects = 0;
  
  SwigClassCashSettlAgentAcctName.klass = rb_define_class_under(mQuickfix, "CashSettlAgentAcctName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentAcctName, (void *) &SwigClassCashSettlAgentAcctName);
  rb_define_alloc_func(SwigClassCashSettlAgentAcctName.klass, _wrap_CashSettlAgentAcctName_allocate);
  rb_define_method(SwigClassCashSettlAgentAcctName.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentAcctName), -1);
  SwigClassCashSettlAgentAcctName.mark = 0;
  SwigClassCashSettlAgentAcctName.destroy = (void (*)(void *)) free_FIX_CashSettlAgentAcctName;
  SwigClassCashSettlAgentAcctName.trackObjects = 0;
  
  SwigClassSellVolume.klass = rb_define_class_under(mQuickfix, "SellVolume", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SellVolume, (void *) &SwigClassSellVolume);
  rb_define_alloc_func(SwigClassSellVolume.klass, _wrap_SellVolume_allocate);
  rb_define_method(SwigClassSellVolume.klass, "initialize", VALUEFUNC(_wrap_new_SellVolume), -1);
  SwigClassSellVolume.mark = 0;
  SwigClassSellVolume.destroy = (void (*)(void *)) free_FIX_SellVolume;
  SwigClassSellVolume.trackObjects = 0;
  
  SwigClassSideMultiLegReportingType.klass = rb_define_class_under(mQuickfix, "SideMultiLegReportingType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideMultiLegReportingType, (void *) &SwigClassSideMultiLegReportingType);
  rb_define_alloc_func(SwigClassSideMultiLegReportingType.klass, _wrap_SideMultiLegReportingType_allocate);
  rb_define_method(SwigClassSideMultiLegReportingType.klass, "initialize", VALUEFUNC(_wrap_new_SideMultiLegReportingType), -1);
  SwigClassSideMultiLegReportingType.mark = 0;
  SwigClassSideMultiLegReportingType.destroy = (void (*)(void *)) free_FIX_SideMultiLegReportingType;
  SwigClassSideMultiLegReportingType.trackObjects = 0;
  
  SwigClassDerivativeEventText.klass = rb_define_class_under(mQuickfix, "DerivativeEventText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventText, (void *) &SwigClassDerivativeEventText);
  rb_define_alloc_func(SwigClassDerivativeEventText.klass, _wrap_DerivativeEventText_allocate);
  rb_define_method(SwigClassDerivativeEventText.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventText), -1);
  SwigClassDerivativeEventText.mark = 0;
  SwigClassDerivativeEventText.destroy = (void (*)(void *)) free_FIX_DerivativeEventText;
  SwigClassDerivativeEventText.trackObjects = 0;
  
  SwigClassPegSecurityDesc.klass = rb_define_class_under(mQuickfix, "PegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSecurityDesc, (void *) &SwigClassPegSecurityDesc);
  rb_define_alloc_func(SwigClassPegSecurityDesc.klass, _wrap_PegSecurityDesc_allocate);
  rb_define_method(SwigClassPegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_PegSecurityDesc), -1);
  SwigClassPegSecurityDesc.mark = 0;
  SwigClassPegSecurityDesc.destroy = (void (*)(void *)) free_FIX_PegSecurityDesc;
  SwigClassPegSecurityDesc.trackObjects = 0;
  
  SwigClassAllocCustomerCapacity.klass = rb_define_class_under(mQuickfix, "AllocCustomerCapacity", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocCustomerCapacity, (void *) &SwigClassAllocCustomerCapacity);
  rb_define_alloc_func(SwigClassAllocCustomerCapacity.klass, _wrap_AllocCustomerCapacity_allocate);
  rb_define_method(SwigClassAllocCustomerCapacity.klass, "initialize", VALUEFUNC(_wrap_new_AllocCustomerCapacity), -1);
  SwigClassAllocCustomerCapacity.mark = 0;
  SwigClassAllocCustomerCapacity.destroy = (void (*)(void *)) free_FIX_AllocCustomerCapacity;
  SwigClassAllocCustomerCapacity.trackObjects = 0;
  
  SwigClassConfirmRejReason.klass = rb_define_class_under(mQuickfix, "ConfirmRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmRejReason, (void *) &SwigClassConfirmRejReason);
  rb_define_alloc_func(SwigClassConfirmRejReason.klass, _wrap_ConfirmRejReason_allocate);
  rb_define_method(SwigClassConfirmRejReason.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmRejReason), -1);
  SwigClassConfirmRejReason.mark = 0;
  SwigClassConfirmRejReason.destroy = (void (*)(void *)) free_FIX_ConfirmRejReason;
  SwigClassConfirmRejReason.trackObjects = 0;
  
  SwigClassBidRequestTransType.klass = rb_define_class_under(mQuickfix, "BidRequestTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidRequestTransType, (void *) &SwigClassBidRequestTransType);
  rb_define_alloc_func(SwigClassBidRequestTransType.klass, _wrap_BidRequestTransType_allocate);
  rb_define_method(SwigClassBidRequestTransType.klass, "initialize", VALUEFUNC(_wrap_new_BidRequestTransType), -1);
  SwigClassBidRequestTransType.mark = 0;
  SwigClassBidRequestTransType.destroy = (void (*)(void *)) free_FIX_BidRequestTransType;
  SwigClassBidRequestTransType.trackObjects = 0;
  
  SwigClassCashDistribAgentAcctNumber.klass = rb_define_class_under(mQuickfix, "CashDistribAgentAcctNumber", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentAcctNumber, (void *) &SwigClassCashDistribAgentAcctNumber);
  rb_define_alloc_func(SwigClassCashDistribAgentAcctNumber.klass, _wrap_CashDistribAgentAcctNumber_allocate);
  rb_define_method(SwigClassCashDistribAgentAcctNumber.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentAcctNumber), -1);
  SwigClassCashDistribAgentAcctNumber.mark = 0;
  SwigClassCashDistribAgentAcctNumber.destroy = (void (*)(void *)) free_FIX_CashDistribAgentAcctNumber;
  SwigClassCashDistribAgentAcctNumber.trackObjects = 0;
  
  SwigClassLegExecInst.klass = rb_define_class_under(mQuickfix, "LegExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegExecInst, (void *) &SwigClassLegExecInst);
  rb_define_alloc_func(SwigClassLegExecInst.klass, _wrap_LegExecInst_allocate);
  rb_define_method(SwigClassLegExecInst.klass, "initialize", VALUEFUNC(_wrap_new_LegExecInst), -1);
  SwigClassLegExecInst.mark = 0;
  SwigClassLegExecInst.destroy = (void (*)(void *)) free_FIX_LegExecInst;
  SwigClassLegExecInst.trackObjects = 0;
  
  SwigClassCapPrice.klass = rb_define_class_under(mQuickfix, "CapPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CapPrice, (void *) &SwigClassCapPrice);
  rb_define_alloc_func(SwigClassCapPrice.klass, _wrap_CapPrice_allocate);
  rb_define_method(SwigClassCapPrice.klass, "initialize", VALUEFUNC(_wrap_new_CapPrice), -1);
  SwigClassCapPrice.mark = 0;
  SwigClassCapPrice.destroy = (void (*)(void *)) free_FIX_CapPrice;
  SwigClassCapPrice.trackObjects = 0;
  
  SwigClassLegRepurchaseTerm.klass = rb_define_class_under(mQuickfix, "LegRepurchaseTerm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRepurchaseTerm, (void *) &SwigClassLegRepurchaseTerm);
  rb_define_alloc_func(SwigClassLegRepurchaseTerm.klass, _wrap_LegRepurchaseTerm_allocate);
  rb_define_method(SwigClassLegRepurchaseTerm.klass, "initialize", VALUEFUNC(_wrap_new_LegRepurchaseTerm), -1);
  SwigClassLegRepurchaseTerm.mark = 0;
  SwigClassLegRepurchaseTerm.destroy = (void (*)(void *)) free_FIX_LegRepurchaseTerm;
  SwigClassLegRepurchaseTerm.trackObjects = 0;
  
  SwigClassRegistAcctType.klass = rb_define_class_under(mQuickfix, "RegistAcctType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistAcctType, (void *) &SwigClassRegistAcctType);
  rb_define_alloc_func(SwigClassRegistAcctType.klass, _wrap_RegistAcctType_allocate);
  rb_define_method(SwigClassRegistAcctType.klass, "initialize", VALUEFUNC(_wrap_new_RegistAcctType), -1);
  SwigClassRegistAcctType.mark = 0;
  SwigClassRegistAcctType.destroy = (void (*)(void *)) free_FIX_RegistAcctType;
  SwigClassRegistAcctType.trackObjects = 0;
  
  SwigClassMassActionRejectReason.klass = rb_define_class_under(mQuickfix, "MassActionRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionRejectReason, (void *) &SwigClassMassActionRejectReason);
  rb_define_alloc_func(SwigClassMassActionRejectReason.klass, _wrap_MassActionRejectReason_allocate);
  rb_define_method(SwigClassMassActionRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_MassActionRejectReason), -1);
  SwigClassMassActionRejectReason.mark = 0;
  SwigClassMassActionRejectReason.destroy = (void (*)(void *)) free_FIX_MassActionRejectReason;
  SwigClassMassActionRejectReason.trackObjects = 0;
  
  SwigClassDerivativePutOrCall.klass = rb_define_class_under(mQuickfix, "DerivativePutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePutOrCall, (void *) &SwigClassDerivativePutOrCall);
  rb_define_alloc_func(SwigClassDerivativePutOrCall.klass, _wrap_DerivativePutOrCall_allocate);
  rb_define_method(SwigClassDerivativePutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePutOrCall), -1);
  SwigClassDerivativePutOrCall.mark = 0;
  SwigClassDerivativePutOrCall.destroy = (void (*)(void *)) free_FIX_DerivativePutOrCall;
  SwigClassDerivativePutOrCall.trackObjects = 0;
  
  SwigClassStartMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "StartMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartMaturityMonthYear, (void *) &SwigClassStartMaturityMonthYear);
  rb_define_alloc_func(SwigClassStartMaturityMonthYear.klass, _wrap_StartMaturityMonthYear_allocate);
  rb_define_method(SwigClassStartMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_StartMaturityMonthYear), -1);
  SwigClassStartMaturityMonthYear.mark = 0;
  SwigClassStartMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_StartMaturityMonthYear;
  SwigClassStartMaturityMonthYear.trackObjects = 0;
  
  SwigClassCollApplType.klass = rb_define_class_under(mQuickfix, "CollApplType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollApplType, (void *) &SwigClassCollApplType);
  rb_define_alloc_func(SwigClassCollApplType.klass, _wrap_CollApplType_allocate);
  rb_define_method(SwigClassCollApplType.klass, "initialize", VALUEFUNC(_wrap_new_CollApplType), -1);
  SwigClassCollApplType.mark = 0;
  SwigClassCollApplType.destroy = (void (*)(void *)) free_FIX_CollApplType;
  SwigClassCollApplType.trackObjects = 0;
  
  SwigClassNoUnderlyingAmounts.klass = rb_define_class_under(mQuickfix, "NoUnderlyingAmounts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingAmounts, (void *) &SwigClassNoUnderlyingAmounts);
  rb_define_alloc_func(SwigClassNoUnderlyingAmounts.klass, _wrap_NoUnderlyingAmounts_allocate);
  rb_define_method(SwigClassNoUnderlyingAmounts.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingAmounts), -1);
  SwigClassNoUnderlyingAmounts.mark = 0;
  SwigClassNoUnderlyingAmounts.destroy = (void (*)(void *)) free_FIX_NoUnderlyingAmounts;
  SwigClassNoUnderlyingAmounts.trackObjects = 0;
  
  SwigClassConfirmType.klass = rb_define_class_under(mQuickfix, "ConfirmType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmType, (void *) &SwigClassConfirmType);
  rb_define_alloc_func(SwigClassConfirmType.klass, _wrap_ConfirmType_allocate);
  rb_define_method(SwigClassConfirmType.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmType), -1);
  SwigClassConfirmType.mark = 0;
  SwigClassConfirmType.destroy = (void (*)(void *)) free_FIX_ConfirmType;
  SwigClassConfirmType.trackObjects = 0;
  
  SwigClassLegMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "LegMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegMaturityMonthYear, (void *) &SwigClassLegMaturityMonthYear);
  rb_define_alloc_func(SwigClassLegMaturityMonthYear.klass, _wrap_LegMaturityMonthYear_allocate);
  rb_define_method(SwigClassLegMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_LegMaturityMonthYear), -1);
  SwigClassLegMaturityMonthYear.mark = 0;
  SwigClassLegMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_LegMaturityMonthYear;
  SwigClassLegMaturityMonthYear.trackObjects = 0;
  
  SwigClassRelatdSym.klass = rb_define_class_under(mQuickfix, "RelatdSym", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatdSym, (void *) &SwigClassRelatdSym);
  rb_define_alloc_func(SwigClassRelatdSym.klass, _wrap_RelatdSym_allocate);
  rb_define_method(SwigClassRelatdSym.klass, "initialize", VALUEFUNC(_wrap_new_RelatdSym), -1);
  SwigClassRelatdSym.mark = 0;
  SwigClassRelatdSym.destroy = (void (*)(void *)) free_FIX_RelatdSym;
  SwigClassRelatdSym.trackObjects = 0;
  
  SwigClassUnderlyingLegSecuritySubType.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType, (void *) &SwigClassUnderlyingLegSecuritySubType);
  rb_define_alloc_func(SwigClassUnderlyingLegSecuritySubType.klass, _wrap_UnderlyingLegSecuritySubType_allocate);
  rb_define_method(SwigClassUnderlyingLegSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecuritySubType), -1);
  SwigClassUnderlyingLegSecuritySubType.mark = 0;
  SwigClassUnderlyingLegSecuritySubType.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecuritySubType;
  SwigClassUnderlyingLegSecuritySubType.trackObjects = 0;
  
  SwigClassNoUnderlyingSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoUnderlyingSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID, (void *) &SwigClassNoUnderlyingSecurityAltID);
  rb_define_alloc_func(SwigClassNoUnderlyingSecurityAltID.klass, _wrap_NoUnderlyingSecurityAltID_allocate);
  rb_define_method(SwigClassNoUnderlyingSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingSecurityAltID), -1);
  SwigClassNoUnderlyingSecurityAltID.mark = 0;
  SwigClassNoUnderlyingSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoUnderlyingSecurityAltID;
  SwigClassNoUnderlyingSecurityAltID.trackObjects = 0;
  
  SwigClassMDQuoteType.klass = rb_define_class_under(mQuickfix, "MDQuoteType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDQuoteType, (void *) &SwigClassMDQuoteType);
  rb_define_alloc_func(SwigClassMDQuoteType.klass, _wrap_MDQuoteType_allocate);
  rb_define_method(SwigClassMDQuoteType.klass, "initialize", VALUEFUNC(_wrap_new_MDQuoteType), -1);
  SwigClassMDQuoteType.mark = 0;
  SwigClassMDQuoteType.destroy = (void (*)(void *)) free_FIX_MDQuoteType;
  SwigClassMDQuoteType.trackObjects = 0;
  
  SwigClassQtyType.klass = rb_define_class_under(mQuickfix, "QtyType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QtyType, (void *) &SwigClassQtyType);
  rb_define_alloc_func(SwigClassQtyType.klass, _wrap_QtyType_allocate);
  rb_define_method(SwigClassQtyType.klass, "initialize", VALUEFUNC(_wrap_new_QtyType), -1);
  SwigClassQtyType.mark = 0;
  SwigClassQtyType.destroy = (void (*)(void *)) free_FIX_QtyType;
  SwigClassQtyType.trackObjects = 0;
  
  SwigClassQuoteRespType.klass = rb_define_class_under(mQuickfix, "QuoteRespType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRespType, (void *) &SwigClassQuoteRespType);
  rb_define_alloc_func(SwigClassQuoteRespType.klass, _wrap_QuoteRespType_allocate);
  rb_define_method(SwigClassQuoteRespType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRespType), -1);
  SwigClassQuoteRespType.mark = 0;
  SwigClassQuoteRespType.destroy = (void (*)(void *)) free_FIX_QuoteRespType;
  SwigClassQuoteRespType.trackObjects = 0;
  
  SwigClassIOINaturalFlag.klass = rb_define_class_under(mQuickfix, "IOINaturalFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOINaturalFlag, (void *) &SwigClassIOINaturalFlag);
  rb_define_alloc_func(SwigClassIOINaturalFlag.klass, _wrap_IOINaturalFlag_allocate);
  rb_define_method(SwigClassIOINaturalFlag.klass, "initialize", VALUEFUNC(_wrap_new_IOINaturalFlag), -1);
  SwigClassIOINaturalFlag.mark = 0;
  SwigClassIOINaturalFlag.destroy = (void (*)(void *)) free_FIX_IOINaturalFlag;
  SwigClassIOINaturalFlag.trackObjects = 0;
  
  SwigClassBenchmarkCurvePoint.klass = rb_define_class_under(mQuickfix, "BenchmarkCurvePoint", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkCurvePoint, (void *) &SwigClassBenchmarkCurvePoint);
  rb_define_alloc_func(SwigClassBenchmarkCurvePoint.klass, _wrap_BenchmarkCurvePoint_allocate);
  rb_define_method(SwigClassBenchmarkCurvePoint.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkCurvePoint), -1);
  SwigClassBenchmarkCurvePoint.mark = 0;
  SwigClassBenchmarkCurvePoint.destroy = (void (*)(void *)) free_FIX_BenchmarkCurvePoint;
  SwigClassBenchmarkCurvePoint.trackObjects = 0;
  
  SwigClassTradSesUpdateAction.klass = rb_define_class_under(mQuickfix, "TradSesUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesUpdateAction, (void *) &SwigClassTradSesUpdateAction);
  rb_define_alloc_func(SwigClassTradSesUpdateAction.klass, _wrap_TradSesUpdateAction_allocate);
  rb_define_method(SwigClassTradSesUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_TradSesUpdateAction), -1);
  SwigClassTradSesUpdateAction.mark = 0;
  SwigClassTradSesUpdateAction.destroy = (void (*)(void *)) free_FIX_TradSesUpdateAction;
  SwigClassTradSesUpdateAction.trackObjects = 0;
  
  SwigClassUnderlyingCashAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingCashAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCashAmount, (void *) &SwigClassUnderlyingCashAmount);
  rb_define_alloc_func(SwigClassUnderlyingCashAmount.klass, _wrap_UnderlyingCashAmount_allocate);
  rb_define_method(SwigClassUnderlyingCashAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCashAmount), -1);
  SwigClassUnderlyingCashAmount.mark = 0;
  SwigClassUnderlyingCashAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingCashAmount;
  SwigClassUnderlyingCashAmount.trackObjects = 0;
  
  SwigClassCollAsgnID.klass = rb_define_class_under(mQuickfix, "CollAsgnID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnID, (void *) &SwigClassCollAsgnID);
  rb_define_alloc_func(SwigClassCollAsgnID.klass, _wrap_CollAsgnID_allocate);
  rb_define_method(SwigClassCollAsgnID.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnID), -1);
  SwigClassCollAsgnID.mark = 0;
  SwigClassCollAsgnID.destroy = (void (*)(void *)) free_FIX_CollAsgnID;
  SwigClassCollAsgnID.trackObjects = 0;
  
  SwigClassExchangeRule.klass = rb_define_class_under(mQuickfix, "ExchangeRule", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExchangeRule, (void *) &SwigClassExchangeRule);
  rb_define_alloc_func(SwigClassExchangeRule.klass, _wrap_ExchangeRule_allocate);
  rb_define_method(SwigClassExchangeRule.klass, "initialize", VALUEFUNC(_wrap_new_ExchangeRule), -1);
  SwigClassExchangeRule.mark = 0;
  SwigClassExchangeRule.destroy = (void (*)(void *)) free_FIX_ExchangeRule;
  SwigClassExchangeRule.trackObjects = 0;
  
  SwigClassEncodedHeadline.klass = rb_define_class_under(mQuickfix, "EncodedHeadline", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedHeadline, (void *) &SwigClassEncodedHeadline);
  rb_define_alloc_func(SwigClassEncodedHeadline.klass, _wrap_EncodedHeadline_allocate);
  rb_define_method(SwigClassEncodedHeadline.klass, "initialize", VALUEFUNC(_wrap_new_EncodedHeadline), -1);
  SwigClassEncodedHeadline.mark = 0;
  SwigClassEncodedHeadline.destroy = (void (*)(void *)) free_FIX_EncodedHeadline;
  SwigClassEncodedHeadline.trackObjects = 0;
  
  SwigClassRegistID.klass = rb_define_class_under(mQuickfix, "RegistID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistID, (void *) &SwigClassRegistID);
  rb_define_alloc_func(SwigClassRegistID.klass, _wrap_RegistID_allocate);
  rb_define_method(SwigClassRegistID.klass, "initialize", VALUEFUNC(_wrap_new_RegistID), -1);
  SwigClassRegistID.mark = 0;
  SwigClassRegistID.destroy = (void (*)(void *)) free_FIX_RegistID;
  SwigClassRegistID.trackObjects = 0;
  
  SwigClassCrossID.klass = rb_define_class_under(mQuickfix, "CrossID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossID, (void *) &SwigClassCrossID);
  rb_define_alloc_func(SwigClassCrossID.klass, _wrap_CrossID_allocate);
  rb_define_method(SwigClassCrossID.klass, "initialize", VALUEFUNC(_wrap_new_CrossID), -1);
  SwigClassCrossID.mark = 0;
  SwigClassCrossID.destroy = (void (*)(void *)) free_FIX_CrossID;
  SwigClassCrossID.trackObjects = 0;
  
  SwigClassNoExecs.klass = rb_define_class_under(mQuickfix, "NoExecs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoExecs, (void *) &SwigClassNoExecs);
  rb_define_alloc_func(SwigClassNoExecs.klass, _wrap_NoExecs_allocate);
  rb_define_method(SwigClassNoExecs.klass, "initialize", VALUEFUNC(_wrap_new_NoExecs), -1);
  SwigClassNoExecs.mark = 0;
  SwigClassNoExecs.destroy = (void (*)(void *)) free_FIX_NoExecs;
  SwigClassNoExecs.trackObjects = 0;
  
  SwigClassDerivativeSecurityGroup.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityGroup", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityGroup, (void *) &SwigClassDerivativeSecurityGroup);
  rb_define_alloc_func(SwigClassDerivativeSecurityGroup.klass, _wrap_DerivativeSecurityGroup_allocate);
  rb_define_method(SwigClassDerivativeSecurityGroup.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityGroup), -1);
  SwigClassDerivativeSecurityGroup.mark = 0;
  SwigClassDerivativeSecurityGroup.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityGroup;
  SwigClassDerivativeSecurityGroup.trackObjects = 0;
  
  SwigClassSecondaryDisplayQty.klass = rb_define_class_under(mQuickfix, "SecondaryDisplayQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryDisplayQty, (void *) &SwigClassSecondaryDisplayQty);
  rb_define_alloc_func(SwigClassSecondaryDisplayQty.klass, _wrap_SecondaryDisplayQty_allocate);
  rb_define_method(SwigClassSecondaryDisplayQty.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryDisplayQty), -1);
  SwigClassSecondaryDisplayQty.mark = 0;
  SwigClassSecondaryDisplayQty.destroy = (void (*)(void *)) free_FIX_SecondaryDisplayQty;
  SwigClassSecondaryDisplayQty.trackObjects = 0;
  
  SwigClassRefMsgType.klass = rb_define_class_under(mQuickfix, "RefMsgType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefMsgType, (void *) &SwigClassRefMsgType);
  rb_define_alloc_func(SwigClassRefMsgType.klass, _wrap_RefMsgType_allocate);
  rb_define_method(SwigClassRefMsgType.klass, "initialize", VALUEFUNC(_wrap_new_RefMsgType), -1);
  SwigClassRefMsgType.mark = 0;
  SwigClassRefMsgType.destroy = (void (*)(void *)) free_FIX_RefMsgType;
  SwigClassRefMsgType.trackObjects = 0;
  
  SwigClassStandInstDbID.klass = rb_define_class_under(mQuickfix, "StandInstDbID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StandInstDbID, (void *) &SwigClassStandInstDbID);
  rb_define_alloc_func(SwigClassStandInstDbID.klass, _wrap_StandInstDbID_allocate);
  rb_define_method(SwigClassStandInstDbID.klass, "initialize", VALUEFUNC(_wrap_new_StandInstDbID), -1);
  SwigClassStandInstDbID.mark = 0;
  SwigClassStandInstDbID.destroy = (void (*)(void *)) free_FIX_StandInstDbID;
  SwigClassStandInstDbID.trackObjects = 0;
  
  SwigClassEncodedLegSecurityDescLen.klass = rb_define_class_under(mQuickfix, "EncodedLegSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegSecurityDescLen, (void *) &SwigClassEncodedLegSecurityDescLen);
  rb_define_alloc_func(SwigClassEncodedLegSecurityDescLen.klass, _wrap_EncodedLegSecurityDescLen_allocate);
  rb_define_method(SwigClassEncodedLegSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegSecurityDescLen), -1);
  SwigClassEncodedLegSecurityDescLen.mark = 0;
  SwigClassEncodedLegSecurityDescLen.destroy = (void (*)(void *)) free_FIX_EncodedLegSecurityDescLen;
  SwigClassEncodedLegSecurityDescLen.trackObjects = 0;
  
  SwigClassDerivativeEventPx.klass = rb_define_class_under(mQuickfix, "DerivativeEventPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventPx, (void *) &SwigClassDerivativeEventPx);
  rb_define_alloc_func(SwigClassDerivativeEventPx.klass, _wrap_DerivativeEventPx_allocate);
  rb_define_method(SwigClassDerivativeEventPx.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventPx), -1);
  SwigClassDerivativeEventPx.mark = 0;
  SwigClassDerivativeEventPx.destroy = (void (*)(void *)) free_FIX_DerivativeEventPx;
  SwigClassDerivativeEventPx.trackObjects = 0;
  
  SwigClassSettlObligSource.klass = rb_define_class_under(mQuickfix, "SettlObligSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligSource, (void *) &SwigClassSettlObligSource);
  rb_define_alloc_func(SwigClassSettlObligSource.klass, _wrap_SettlObligSource_allocate);
  rb_define_method(SwigClassSettlObligSource.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligSource), -1);
  SwigClassSettlObligSource.mark = 0;
  SwigClassSettlObligSource.destroy = (void (*)(void *)) free_FIX_SettlObligSource;
  SwigClassSettlObligSource.trackObjects = 0;
  
  SwigClassTrdSubType.klass = rb_define_class_under(mQuickfix, "TrdSubType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdSubType, (void *) &SwigClassTrdSubType);
  rb_define_alloc_func(SwigClassTrdSubType.klass, _wrap_TrdSubType_allocate);
  rb_define_method(SwigClassTrdSubType.klass, "initialize", VALUEFUNC(_wrap_new_TrdSubType), -1);
  SwigClassTrdSubType.mark = 0;
  SwigClassTrdSubType.destroy = (void (*)(void *)) free_FIX_TrdSubType;
  SwigClassTrdSubType.trackObjects = 0;
  
  SwigClassEncodedUnderlyingIssuerLen.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen, (void *) &SwigClassEncodedUnderlyingIssuerLen);
  rb_define_alloc_func(SwigClassEncodedUnderlyingIssuerLen.klass, _wrap_EncodedUnderlyingIssuerLen_allocate);
  rb_define_method(SwigClassEncodedUnderlyingIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingIssuerLen), -1);
  SwigClassEncodedUnderlyingIssuerLen.mark = 0;
  SwigClassEncodedUnderlyingIssuerLen.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingIssuerLen;
  SwigClassEncodedUnderlyingIssuerLen.trackObjects = 0;
  
  SwigClassExecTransType.klass = rb_define_class_under(mQuickfix, "ExecTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecTransType, (void *) &SwigClassExecTransType);
  rb_define_alloc_func(SwigClassExecTransType.klass, _wrap_ExecTransType_allocate);
  rb_define_method(SwigClassExecTransType.klass, "initialize", VALUEFUNC(_wrap_new_ExecTransType), -1);
  SwigClassExecTransType.mark = 0;
  SwigClassExecTransType.destroy = (void (*)(void *)) free_FIX_ExecTransType;
  SwigClassExecTransType.trackObjects = 0;
  
  SwigClassBeginSeqNo.klass = rb_define_class_under(mQuickfix, "BeginSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BeginSeqNo, (void *) &SwigClassBeginSeqNo);
  rb_define_alloc_func(SwigClassBeginSeqNo.klass, _wrap_BeginSeqNo_allocate);
  rb_define_method(SwigClassBeginSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_BeginSeqNo), -1);
  SwigClassBeginSeqNo.mark = 0;
  SwigClassBeginSeqNo.destroy = (void (*)(void *)) free_FIX_BeginSeqNo;
  SwigClassBeginSeqNo.trackObjects = 0;
  
  SwigClassDayBookingInst.klass = rb_define_class_under(mQuickfix, "DayBookingInst", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayBookingInst, (void *) &SwigClassDayBookingInst);
  rb_define_alloc_func(SwigClassDayBookingInst.klass, _wrap_DayBookingInst_allocate);
  rb_define_method(SwigClassDayBookingInst.klass, "initialize", VALUEFUNC(_wrap_new_DayBookingInst), -1);
  SwigClassDayBookingInst.mark = 0;
  SwigClassDayBookingInst.destroy = (void (*)(void *)) free_FIX_DayBookingInst;
  SwigClassDayBookingInst.trackObjects = 0;
  
  SwigClassFlowScheduleType.klass = rb_define_class_under(mQuickfix, "FlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FlowScheduleType, (void *) &SwigClassFlowScheduleType);
  rb_define_alloc_func(SwigClassFlowScheduleType.klass, _wrap_FlowScheduleType_allocate);
  rb_define_method(SwigClassFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_FlowScheduleType), -1);
  SwigClassFlowScheduleType.mark = 0;
  SwigClassFlowScheduleType.destroy = (void (*)(void *)) free_FIX_FlowScheduleType;
  SwigClassFlowScheduleType.trackObjects = 0;
  
  SwigClassMDOriginType.klass = rb_define_class_under(mQuickfix, "MDOriginType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDOriginType, (void *) &SwigClassMDOriginType);
  rb_define_alloc_func(SwigClassMDOriginType.klass, _wrap_MDOriginType_allocate);
  rb_define_method(SwigClassMDOriginType.klass, "initialize", VALUEFUNC(_wrap_new_MDOriginType), -1);
  SwigClassMDOriginType.mark = 0;
  SwigClassMDOriginType.destroy = (void (*)(void *)) free_FIX_MDOriginType;
  SwigClassMDOriginType.trackObjects = 0;
  
  SwigClassCollInquiryStatus.klass = rb_define_class_under(mQuickfix, "CollInquiryStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryStatus, (void *) &SwigClassCollInquiryStatus);
  rb_define_alloc_func(SwigClassCollInquiryStatus.klass, _wrap_CollInquiryStatus_allocate);
  rb_define_method(SwigClassCollInquiryStatus.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryStatus), -1);
  SwigClassCollInquiryStatus.mark = 0;
  SwigClassCollInquiryStatus.destroy = (void (*)(void *)) free_FIX_CollInquiryStatus;
  SwigClassCollInquiryStatus.trackObjects = 0;
  
  SwigClassNoInstrAttrib.klass = rb_define_class_under(mQuickfix, "NoInstrAttrib", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoInstrAttrib, (void *) &SwigClassNoInstrAttrib);
  rb_define_alloc_func(SwigClassNoInstrAttrib.klass, _wrap_NoInstrAttrib_allocate);
  rb_define_method(SwigClassNoInstrAttrib.klass, "initialize", VALUEFUNC(_wrap_new_NoInstrAttrib), -1);
  SwigClassNoInstrAttrib.mark = 0;
  SwigClassNoInstrAttrib.destroy = (void (*)(void *)) free_FIX_NoInstrAttrib;
  SwigClassNoInstrAttrib.trackObjects = 0;
  
  SwigClassRegistEmail.klass = rb_define_class_under(mQuickfix, "RegistEmail", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistEmail, (void *) &SwigClassRegistEmail);
  rb_define_alloc_func(SwigClassRegistEmail.klass, _wrap_RegistEmail_allocate);
  rb_define_method(SwigClassRegistEmail.klass, "initialize", VALUEFUNC(_wrap_new_RegistEmail), -1);
  SwigClassRegistEmail.mark = 0;
  SwigClassRegistEmail.destroy = (void (*)(void *)) free_FIX_RegistEmail;
  SwigClassRegistEmail.trackObjects = 0;
  
  SwigClassStreamAsgnReqID.klass = rb_define_class_under(mQuickfix, "StreamAsgnReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnReqID, (void *) &SwigClassStreamAsgnReqID);
  rb_define_alloc_func(SwigClassStreamAsgnReqID.klass, _wrap_StreamAsgnReqID_allocate);
  rb_define_method(SwigClassStreamAsgnReqID.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnReqID), -1);
  SwigClassStreamAsgnReqID.mark = 0;
  SwigClassStreamAsgnReqID.destroy = (void (*)(void *)) free_FIX_StreamAsgnReqID;
  SwigClassStreamAsgnReqID.trackObjects = 0;
  
  SwigClassCPProgram.klass = rb_define_class_under(mQuickfix, "CPProgram", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CPProgram, (void *) &SwigClassCPProgram);
  rb_define_alloc_func(SwigClassCPProgram.klass, _wrap_CPProgram_allocate);
  rb_define_method(SwigClassCPProgram.klass, "initialize", VALUEFUNC(_wrap_new_CPProgram), -1);
  SwigClassCPProgram.mark = 0;
  SwigClassCPProgram.destroy = (void (*)(void *)) free_FIX_CPProgram;
  SwigClassCPProgram.trackObjects = 0;
  
  SwigClassConfirmReqID.klass = rb_define_class_under(mQuickfix, "ConfirmReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmReqID, (void *) &SwigClassConfirmReqID);
  rb_define_alloc_func(SwigClassConfirmReqID.klass, _wrap_ConfirmReqID_allocate);
  rb_define_method(SwigClassConfirmReqID.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmReqID), -1);
  SwigClassConfirmReqID.mark = 0;
  SwigClassConfirmReqID.destroy = (void (*)(void *)) free_FIX_ConfirmReqID;
  SwigClassConfirmReqID.trackObjects = 0;
  
  SwigClassAltMDSourceID.klass = rb_define_class_under(mQuickfix, "AltMDSourceID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AltMDSourceID, (void *) &SwigClassAltMDSourceID);
  rb_define_alloc_func(SwigClassAltMDSourceID.klass, _wrap_AltMDSourceID_allocate);
  rb_define_method(SwigClassAltMDSourceID.klass, "initialize", VALUEFUNC(_wrap_new_AltMDSourceID), -1);
  SwigClassAltMDSourceID.mark = 0;
  SwigClassAltMDSourceID.destroy = (void (*)(void *)) free_FIX_AltMDSourceID;
  SwigClassAltMDSourceID.trackObjects = 0;
  
  SwigClassNoOrders.klass = rb_define_class_under(mQuickfix, "NoOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOrders, (void *) &SwigClassNoOrders);
  rb_define_alloc_func(SwigClassNoOrders.klass, _wrap_NoOrders_allocate);
  rb_define_method(SwigClassNoOrders.klass, "initialize", VALUEFUNC(_wrap_new_NoOrders), -1);
  SwigClassNoOrders.mark = 0;
  SwigClassNoOrders.destroy = (void (*)(void *)) free_FIX_NoOrders;
  SwigClassNoOrders.trackObjects = 0;
  
  SwigClassCashDistribAgentAcctName.klass = rb_define_class_under(mQuickfix, "CashDistribAgentAcctName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentAcctName, (void *) &SwigClassCashDistribAgentAcctName);
  rb_define_alloc_func(SwigClassCashDistribAgentAcctName.klass, _wrap_CashDistribAgentAcctName_allocate);
  rb_define_method(SwigClassCashDistribAgentAcctName.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentAcctName), -1);
  SwigClassCashDistribAgentAcctName.mark = 0;
  SwigClassCashDistribAgentAcctName.destroy = (void (*)(void *)) free_FIX_CashDistribAgentAcctName;
  SwigClassCashDistribAgentAcctName.trackObjects = 0;
  
  SwigClassUndlyInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource, (void *) &SwigClassUndlyInstrumentPartyIDSource);
  rb_define_alloc_func(SwigClassUndlyInstrumentPartyIDSource.klass, _wrap_UndlyInstrumentPartyIDSource_allocate);
  rb_define_method(SwigClassUndlyInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartyIDSource), -1);
  SwigClassUndlyInstrumentPartyIDSource.mark = 0;
  SwigClassUndlyInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartyIDSource;
  SwigClassUndlyInstrumentPartyIDSource.trackObjects = 0;
  
  SwigClassUnderlyingSettlMethod.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlMethod, (void *) &SwigClassUnderlyingSettlMethod);
  rb_define_alloc_func(SwigClassUnderlyingSettlMethod.klass, _wrap_UnderlyingSettlMethod_allocate);
  rb_define_method(SwigClassUnderlyingSettlMethod.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlMethod), -1);
  SwigClassUnderlyingSettlMethod.mark = 0;
  SwigClassUnderlyingSettlMethod.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlMethod;
  SwigClassUnderlyingSettlMethod.trackObjects = 0;
  
  SwigClassNoMDEntryTypes.klass = rb_define_class_under(mQuickfix, "NoMDEntryTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMDEntryTypes, (void *) &SwigClassNoMDEntryTypes);
  rb_define_alloc_func(SwigClassNoMDEntryTypes.klass, _wrap_NoMDEntryTypes_allocate);
  rb_define_method(SwigClassNoMDEntryTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoMDEntryTypes), -1);
  SwigClassNoMDEntryTypes.mark = 0;
  SwigClassNoMDEntryTypes.destroy = (void (*)(void *)) free_FIX_NoMDEntryTypes;
  SwigClassNoMDEntryTypes.trackObjects = 0;
  
  SwigClassMDEntryForwardPoints.klass = rb_define_class_under(mQuickfix, "MDEntryForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryForwardPoints, (void *) &SwigClassMDEntryForwardPoints);
  rb_define_alloc_func(SwigClassMDEntryForwardPoints.klass, _wrap_MDEntryForwardPoints_allocate);
  rb_define_method(SwigClassMDEntryForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryForwardPoints), -1);
  SwigClassMDEntryForwardPoints.mark = 0;
  SwigClassMDEntryForwardPoints.destroy = (void (*)(void *)) free_FIX_MDEntryForwardPoints;
  SwigClassMDEntryForwardPoints.trackObjects = 0;
  
  SwigClassPosReqType.klass = rb_define_class_under(mQuickfix, "PosReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqType, (void *) &SwigClassPosReqType);
  rb_define_alloc_func(SwigClassPosReqType.klass, _wrap_PosReqType_allocate);
  rb_define_method(SwigClassPosReqType.klass, "initialize", VALUEFUNC(_wrap_new_PosReqType), -1);
  SwigClassPosReqType.mark = 0;
  SwigClassPosReqType.destroy = (void (*)(void *)) free_FIX_PosReqType;
  SwigClassPosReqType.trackObjects = 0;
  
  SwigClassMassStatusReqType.klass = rb_define_class_under(mQuickfix, "MassStatusReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassStatusReqType, (void *) &SwigClassMassStatusReqType);
  rb_define_alloc_func(SwigClassMassStatusReqType.klass, _wrap_MassStatusReqType_allocate);
  rb_define_method(SwigClassMassStatusReqType.klass, "initialize", VALUEFUNC(_wrap_new_MassStatusReqType), -1);
  SwigClassMassStatusReqType.mark = 0;
  SwigClassMassStatusReqType.destroy = (void (*)(void *)) free_FIX_MassStatusReqType;
  SwigClassMassStatusReqType.trackObjects = 0;
  
  SwigClassTradeOriginationDate.klass = rb_define_class_under(mQuickfix, "TradeOriginationDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeOriginationDate, (void *) &SwigClassTradeOriginationDate);
  rb_define_alloc_func(SwigClassTradeOriginationDate.klass, _wrap_TradeOriginationDate_allocate);
  rb_define_method(SwigClassTradeOriginationDate.klass, "initialize", VALUEFUNC(_wrap_new_TradeOriginationDate), -1);
  SwigClassTradeOriginationDate.mark = 0;
  SwigClassTradeOriginationDate.destroy = (void (*)(void *)) free_FIX_TradeOriginationDate;
  SwigClassTradeOriginationDate.trackObjects = 0;
  
  SwigClassSettlPrice.klass = rb_define_class_under(mQuickfix, "SettlPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPrice, (void *) &SwigClassSettlPrice);
  rb_define_alloc_func(SwigClassSettlPrice.klass, _wrap_SettlPrice_allocate);
  rb_define_method(SwigClassSettlPrice.klass, "initialize", VALUEFUNC(_wrap_new_SettlPrice), -1);
  SwigClassSettlPrice.mark = 0;
  SwigClassSettlPrice.destroy = (void (*)(void *)) free_FIX_SettlPrice;
  SwigClassSettlPrice.trackObjects = 0;
  
  SwigClassSecuritySettlAgentAcctName.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentAcctName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentAcctName, (void *) &SwigClassSecuritySettlAgentAcctName);
  rb_define_alloc_func(SwigClassSecuritySettlAgentAcctName.klass, _wrap_SecuritySettlAgentAcctName_allocate);
  rb_define_method(SwigClassSecuritySettlAgentAcctName.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentAcctName), -1);
  SwigClassSecuritySettlAgentAcctName.mark = 0;
  SwigClassSecuritySettlAgentAcctName.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentAcctName;
  SwigClassSecuritySettlAgentAcctName.trackObjects = 0;
  
  SwigClassNoDerivativeEvents.klass = rb_define_class_under(mQuickfix, "NoDerivativeEvents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeEvents, (void *) &SwigClassNoDerivativeEvents);
  rb_define_alloc_func(SwigClassNoDerivativeEvents.klass, _wrap_NoDerivativeEvents_allocate);
  rb_define_method(SwigClassNoDerivativeEvents.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeEvents), -1);
  SwigClassNoDerivativeEvents.mark = 0;
  SwigClassNoDerivativeEvents.destroy = (void (*)(void *)) free_FIX_NoDerivativeEvents;
  SwigClassNoDerivativeEvents.trackObjects = 0;
  
  SwigClassUnderlyingEndPrice.klass = rb_define_class_under(mQuickfix, "UnderlyingEndPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingEndPrice, (void *) &SwigClassUnderlyingEndPrice);
  rb_define_alloc_func(SwigClassUnderlyingEndPrice.klass, _wrap_UnderlyingEndPrice_allocate);
  rb_define_method(SwigClassUnderlyingEndPrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingEndPrice), -1);
  SwigClassUnderlyingEndPrice.mark = 0;
  SwigClassUnderlyingEndPrice.destroy = (void (*)(void *)) free_FIX_UnderlyingEndPrice;
  SwigClassUnderlyingEndPrice.trackObjects = 0;
  
  SwigClassSubscriptionRequestType.klass = rb_define_class_under(mQuickfix, "SubscriptionRequestType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SubscriptionRequestType, (void *) &SwigClassSubscriptionRequestType);
  rb_define_alloc_func(SwigClassSubscriptionRequestType.klass, _wrap_SubscriptionRequestType_allocate);
  rb_define_method(SwigClassSubscriptionRequestType.klass, "initialize", VALUEFUNC(_wrap_new_SubscriptionRequestType), -1);
  SwigClassSubscriptionRequestType.mark = 0;
  SwigClassSubscriptionRequestType.destroy = (void (*)(void *)) free_FIX_SubscriptionRequestType;
  SwigClassSubscriptionRequestType.trackObjects = 0;
  
  SwigClassTotalNumSecurityTypes.klass = rb_define_class_under(mQuickfix, "TotalNumSecurityTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNumSecurityTypes, (void *) &SwigClassTotalNumSecurityTypes);
  rb_define_alloc_func(SwigClassTotalNumSecurityTypes.klass, _wrap_TotalNumSecurityTypes_allocate);
  rb_define_method(SwigClassTotalNumSecurityTypes.klass, "initialize", VALUEFUNC(_wrap_new_TotalNumSecurityTypes), -1);
  SwigClassTotalNumSecurityTypes.mark = 0;
  SwigClassTotalNumSecurityTypes.destroy = (void (*)(void *)) free_FIX_TotalNumSecurityTypes;
  SwigClassTotalNumSecurityTypes.trackObjects = 0;
  
  SwigClassNewsCategory.klass = rb_define_class_under(mQuickfix, "NewsCategory", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsCategory, (void *) &SwigClassNewsCategory);
  rb_define_alloc_func(SwigClassNewsCategory.klass, _wrap_NewsCategory_allocate);
  rb_define_method(SwigClassNewsCategory.klass, "initialize", VALUEFUNC(_wrap_new_NewsCategory), -1);
  SwigClassNewsCategory.mark = 0;
  SwigClassNewsCategory.destroy = (void (*)(void *)) free_FIX_NewsCategory;
  SwigClassNewsCategory.trackObjects = 0;
  
  SwigClassUnderlyingLegPutOrCall.klass = rb_define_class_under(mQuickfix, "UnderlyingLegPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegPutOrCall, (void *) &SwigClassUnderlyingLegPutOrCall);
  rb_define_alloc_func(SwigClassUnderlyingLegPutOrCall.klass, _wrap_UnderlyingLegPutOrCall_allocate);
  rb_define_method(SwigClassUnderlyingLegPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegPutOrCall), -1);
  SwigClassUnderlyingLegPutOrCall.mark = 0;
  SwigClassUnderlyingLegPutOrCall.destroy = (void (*)(void *)) free_FIX_UnderlyingLegPutOrCall;
  SwigClassUnderlyingLegPutOrCall.trackObjects = 0;
  
  SwigClassURLLink.klass = rb_define_class_under(mQuickfix, "URLLink", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__URLLink, (void *) &SwigClassURLLink);
  rb_define_alloc_func(SwigClassURLLink.klass, _wrap_URLLink_allocate);
  rb_define_method(SwigClassURLLink.klass, "initialize", VALUEFUNC(_wrap_new_URLLink), -1);
  SwigClassURLLink.mark = 0;
  SwigClassURLLink.destroy = (void (*)(void *)) free_FIX_URLLink;
  SwigClassURLLink.trackObjects = 0;
  
  SwigClassNoInstrumentPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoInstrumentPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoInstrumentPartySubIDs, (void *) &SwigClassNoInstrumentPartySubIDs);
  rb_define_alloc_func(SwigClassNoInstrumentPartySubIDs.klass, _wrap_NoInstrumentPartySubIDs_allocate);
  rb_define_method(SwigClassNoInstrumentPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoInstrumentPartySubIDs), -1);
  SwigClassNoInstrumentPartySubIDs.mark = 0;
  SwigClassNoInstrumentPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoInstrumentPartySubIDs;
  SwigClassNoInstrumentPartySubIDs.trackObjects = 0;
  
  SwigClassUnderlyingCurrentValue.klass = rb_define_class_under(mQuickfix, "UnderlyingCurrentValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCurrentValue, (void *) &SwigClassUnderlyingCurrentValue);
  rb_define_alloc_func(SwigClassUnderlyingCurrentValue.klass, _wrap_UnderlyingCurrentValue_allocate);
  rb_define_method(SwigClassUnderlyingCurrentValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCurrentValue), -1);
  SwigClassUnderlyingCurrentValue.mark = 0;
  SwigClassUnderlyingCurrentValue.destroy = (void (*)(void *)) free_FIX_UnderlyingCurrentValue;
  SwigClassUnderlyingCurrentValue.trackObjects = 0;
  
  SwigClassInterestAccrualDate.klass = rb_define_class_under(mQuickfix, "InterestAccrualDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InterestAccrualDate, (void *) &SwigClassInterestAccrualDate);
  rb_define_alloc_func(SwigClassInterestAccrualDate.klass, _wrap_InterestAccrualDate_allocate);
  rb_define_method(SwigClassInterestAccrualDate.klass, "initialize", VALUEFUNC(_wrap_new_InterestAccrualDate), -1);
  SwigClassInterestAccrualDate.mark = 0;
  SwigClassInterestAccrualDate.destroy = (void (*)(void *)) free_FIX_InterestAccrualDate;
  SwigClassInterestAccrualDate.trackObjects = 0;
  
  SwigClassFutSettDate2.klass = rb_define_class_under(mQuickfix, "FutSettDate2", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FutSettDate2, (void *) &SwigClassFutSettDate2);
  rb_define_alloc_func(SwigClassFutSettDate2.klass, _wrap_FutSettDate2_allocate);
  rb_define_method(SwigClassFutSettDate2.klass, "initialize", VALUEFUNC(_wrap_new_FutSettDate2), -1);
  SwigClassFutSettDate2.mark = 0;
  SwigClassFutSettDate2.destroy = (void (*)(void *)) free_FIX_FutSettDate2;
  SwigClassFutSettDate2.trackObjects = 0;
  
  SwigClassNoClearingInstructions.klass = rb_define_class_under(mQuickfix, "NoClearingInstructions", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoClearingInstructions, (void *) &SwigClassNoClearingInstructions);
  rb_define_alloc_func(SwigClassNoClearingInstructions.klass, _wrap_NoClearingInstructions_allocate);
  rb_define_method(SwigClassNoClearingInstructions.klass, "initialize", VALUEFUNC(_wrap_new_NoClearingInstructions), -1);
  SwigClassNoClearingInstructions.mark = 0;
  SwigClassNoClearingInstructions.destroy = (void (*)(void *)) free_FIX_NoClearingInstructions;
  SwigClassNoClearingInstructions.trackObjects = 0;
  
  SwigClassUnderlyingCurrency.klass = rb_define_class_under(mQuickfix, "UnderlyingCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCurrency, (void *) &SwigClassUnderlyingCurrency);
  rb_define_alloc_func(SwigClassUnderlyingCurrency.klass, _wrap_UnderlyingCurrency_allocate);
  rb_define_method(SwigClassUnderlyingCurrency.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCurrency), -1);
  SwigClassUnderlyingCurrency.mark = 0;
  SwigClassUnderlyingCurrency.destroy = (void (*)(void *)) free_FIX_UnderlyingCurrency;
  SwigClassUnderlyingCurrency.trackObjects = 0;
  
  SwigClassLegInterestAccrualDate.klass = rb_define_class_under(mQuickfix, "LegInterestAccrualDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegInterestAccrualDate, (void *) &SwigClassLegInterestAccrualDate);
  rb_define_alloc_func(SwigClassLegInterestAccrualDate.klass, _wrap_LegInterestAccrualDate_allocate);
  rb_define_method(SwigClassLegInterestAccrualDate.klass, "initialize", VALUEFUNC(_wrap_new_LegInterestAccrualDate), -1);
  SwigClassLegInterestAccrualDate.mark = 0;
  SwigClassLegInterestAccrualDate.destroy = (void (*)(void *)) free_FIX_LegInterestAccrualDate;
  SwigClassLegInterestAccrualDate.trackObjects = 0;
  
  SwigClassNewPassword.klass = rb_define_class_under(mQuickfix, "NewPassword", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewPassword, (void *) &SwigClassNewPassword);
  rb_define_alloc_func(SwigClassNewPassword.klass, _wrap_NewPassword_allocate);
  rb_define_method(SwigClassNewPassword.klass, "initialize", VALUEFUNC(_wrap_new_NewPassword), -1);
  SwigClassNewPassword.mark = 0;
  SwigClassNewPassword.destroy = (void (*)(void *)) free_FIX_NewPassword;
  SwigClassNewPassword.trackObjects = 0;
  
  SwigClassRedemptionDate.klass = rb_define_class_under(mQuickfix, "RedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RedemptionDate, (void *) &SwigClassRedemptionDate);
  rb_define_alloc_func(SwigClassRedemptionDate.klass, _wrap_RedemptionDate_allocate);
  rb_define_method(SwigClassRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_RedemptionDate), -1);
  SwigClassRedemptionDate.mark = 0;
  SwigClassRedemptionDate.destroy = (void (*)(void *)) free_FIX_RedemptionDate;
  SwigClassRedemptionDate.trackObjects = 0;
  
  SwigClassRefApplLastSeqNum.klass = rb_define_class_under(mQuickfix, "RefApplLastSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplLastSeqNum, (void *) &SwigClassRefApplLastSeqNum);
  rb_define_alloc_func(SwigClassRefApplLastSeqNum.klass, _wrap_RefApplLastSeqNum_allocate);
  rb_define_method(SwigClassRefApplLastSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_RefApplLastSeqNum), -1);
  SwigClassRefApplLastSeqNum.mark = 0;
  SwigClassRefApplLastSeqNum.destroy = (void (*)(void *)) free_FIX_RefApplLastSeqNum;
  SwigClassRefApplLastSeqNum.trackObjects = 0;
  
  SwigClassStartCash.klass = rb_define_class_under(mQuickfix, "StartCash", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartCash, (void *) &SwigClassStartCash);
  rb_define_alloc_func(SwigClassStartCash.klass, _wrap_StartCash_allocate);
  rb_define_method(SwigClassStartCash.klass, "initialize", VALUEFUNC(_wrap_new_StartCash), -1);
  SwigClassStartCash.mark = 0;
  SwigClassStartCash.destroy = (void (*)(void *)) free_FIX_StartCash;
  SwigClassStartCash.trackObjects = 0;
  
  SwigClassMaxMessageSize.klass = rb_define_class_under(mQuickfix, "MaxMessageSize", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxMessageSize, (void *) &SwigClassMaxMessageSize);
  rb_define_alloc_func(SwigClassMaxMessageSize.klass, _wrap_MaxMessageSize_allocate);
  rb_define_method(SwigClassMaxMessageSize.klass, "initialize", VALUEFUNC(_wrap_new_MaxMessageSize), -1);
  SwigClassMaxMessageSize.mark = 0;
  SwigClassMaxMessageSize.destroy = (void (*)(void *)) free_FIX_MaxMessageSize;
  SwigClassMaxMessageSize.trackObjects = 0;
  
  SwigClassOfferForwardPoints.klass = rb_define_class_under(mQuickfix, "OfferForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferForwardPoints, (void *) &SwigClassOfferForwardPoints);
  rb_define_alloc_func(SwigClassOfferForwardPoints.klass, _wrap_OfferForwardPoints_allocate);
  rb_define_method(SwigClassOfferForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_OfferForwardPoints), -1);
  SwigClassOfferForwardPoints.mark = 0;
  SwigClassOfferForwardPoints.destroy = (void (*)(void *)) free_FIX_OfferForwardPoints;
  SwigClassOfferForwardPoints.trackObjects = 0;
  
  SwigClassIOIQty.klass = rb_define_class_under(mQuickfix, "IOIQty", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIQty, (void *) &SwigClassIOIQty);
  rb_define_alloc_func(SwigClassIOIQty.klass, _wrap_IOIQty_allocate);
  rb_define_method(SwigClassIOIQty.klass, "initialize", VALUEFUNC(_wrap_new_IOIQty), -1);
  SwigClassIOIQty.mark = 0;
  SwigClassIOIQty.destroy = (void (*)(void *)) free_FIX_IOIQty;
  SwigClassIOIQty.trackObjects = 0;
  
  SwigClassLastQty.klass = rb_define_class_under(mQuickfix, "LastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastQty, (void *) &SwigClassLastQty);
  rb_define_alloc_func(SwigClassLastQty.klass, _wrap_LastQty_allocate);
  rb_define_method(SwigClassLastQty.klass, "initialize", VALUEFUNC(_wrap_new_LastQty), -1);
  SwigClassLastQty.mark = 0;
  SwigClassLastQty.destroy = (void (*)(void *)) free_FIX_LastQty;
  SwigClassLastQty.trackObjects = 0;
  
  SwigClassApplResponseError.klass = rb_define_class_under(mQuickfix, "ApplResponseError", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResponseError, (void *) &SwigClassApplResponseError);
  rb_define_alloc_func(SwigClassApplResponseError.klass, _wrap_ApplResponseError_allocate);
  rb_define_method(SwigClassApplResponseError.klass, "initialize", VALUEFUNC(_wrap_new_ApplResponseError), -1);
  SwigClassApplResponseError.mark = 0;
  SwigClassApplResponseError.destroy = (void (*)(void *)) free_FIX_ApplResponseError;
  SwigClassApplResponseError.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityType.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityType, (void *) &SwigClassUnderlyingLegSecurityType);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityType.klass, _wrap_UnderlyingLegSecurityType_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityType), -1);
  SwigClassUnderlyingLegSecurityType.mark = 0;
  SwigClassUnderlyingLegSecurityType.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityType;
  SwigClassUnderlyingLegSecurityType.trackObjects = 0;
  
  SwigClassDerivativePriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "DerivativePriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure, (void *) &SwigClassDerivativePriceUnitOfMeasure);
  rb_define_alloc_func(SwigClassDerivativePriceUnitOfMeasure.klass, _wrap_DerivativePriceUnitOfMeasure_allocate);
  rb_define_method(SwigClassDerivativePriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePriceUnitOfMeasure), -1);
  SwigClassDerivativePriceUnitOfMeasure.mark = 0;
  SwigClassDerivativePriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_DerivativePriceUnitOfMeasure;
  SwigClassDerivativePriceUnitOfMeasure.trackObjects = 0;
  
  SwigClassTriggerPriceDirection.klass = rb_define_class_under(mQuickfix, "TriggerPriceDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPriceDirection, (void *) &SwigClassTriggerPriceDirection);
  rb_define_alloc_func(SwigClassTriggerPriceDirection.klass, _wrap_TriggerPriceDirection_allocate);
  rb_define_method(SwigClassTriggerPriceDirection.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPriceDirection), -1);
  SwigClassTriggerPriceDirection.mark = 0;
  SwigClassTriggerPriceDirection.destroy = (void (*)(void *)) free_FIX_TriggerPriceDirection;
  SwigClassTriggerPriceDirection.trackObjects = 0;
  
  SwigClassPositionCurrency.klass = rb_define_class_under(mQuickfix, "PositionCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PositionCurrency, (void *) &SwigClassPositionCurrency);
  rb_define_alloc_func(SwigClassPositionCurrency.klass, _wrap_PositionCurrency_allocate);
  rb_define_method(SwigClassPositionCurrency.klass, "initialize", VALUEFUNC(_wrap_new_PositionCurrency), -1);
  SwigClassPositionCurrency.mark = 0;
  SwigClassPositionCurrency.destroy = (void (*)(void *)) free_FIX_PositionCurrency;
  SwigClassPositionCurrency.trackObjects = 0;
  
  SwigClassMessageEventSource.klass = rb_define_class_under(mQuickfix, "MessageEventSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageEventSource, (void *) &SwigClassMessageEventSource);
  rb_define_alloc_func(SwigClassMessageEventSource.klass, _wrap_MessageEventSource_allocate);
  rb_define_method(SwigClassMessageEventSource.klass, "initialize", VALUEFUNC(_wrap_new_MessageEventSource), -1);
  SwigClassMessageEventSource.mark = 0;
  SwigClassMessageEventSource.destroy = (void (*)(void *)) free_FIX_MessageEventSource;
  SwigClassMessageEventSource.trackObjects = 0;
  
  SwigClassCollInquiryID.klass = rb_define_class_under(mQuickfix, "CollInquiryID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryID, (void *) &SwigClassCollInquiryID);
  rb_define_alloc_func(SwigClassCollInquiryID.klass, _wrap_CollInquiryID_allocate);
  rb_define_method(SwigClassCollInquiryID.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryID), -1);
  SwigClassCollInquiryID.mark = 0;
  SwigClassCollInquiryID.destroy = (void (*)(void *)) free_FIX_CollInquiryID;
  SwigClassCollInquiryID.trackObjects = 0;
  
  SwigClassUnderlyingStartValue.klass = rb_define_class_under(mQuickfix, "UnderlyingStartValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStartValue, (void *) &SwigClassUnderlyingStartValue);
  rb_define_alloc_func(SwigClassUnderlyingStartValue.klass, _wrap_UnderlyingStartValue_allocate);
  rb_define_method(SwigClassUnderlyingStartValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStartValue), -1);
  SwigClassUnderlyingStartValue.mark = 0;
  SwigClassUnderlyingStartValue.destroy = (void (*)(void *)) free_FIX_UnderlyingStartValue;
  SwigClassUnderlyingStartValue.trackObjects = 0;
  
  SwigClassLastLiquidityInd.klass = rb_define_class_under(mQuickfix, "LastLiquidityInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastLiquidityInd, (void *) &SwigClassLastLiquidityInd);
  rb_define_alloc_func(SwigClassLastLiquidityInd.klass, _wrap_LastLiquidityInd_allocate);
  rb_define_method(SwigClassLastLiquidityInd.klass, "initialize", VALUEFUNC(_wrap_new_LastLiquidityInd), -1);
  SwigClassLastLiquidityInd.mark = 0;
  SwigClassLastLiquidityInd.destroy = (void (*)(void *)) free_FIX_LastLiquidityInd;
  SwigClassLastLiquidityInd.trackObjects = 0;
  
  SwigClassSecurityID.klass = rb_define_class_under(mQuickfix, "SecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityID, (void *) &SwigClassSecurityID);
  rb_define_alloc_func(SwigClassSecurityID.klass, _wrap_SecurityID_allocate);
  rb_define_method(SwigClassSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityID), -1);
  SwigClassSecurityID.mark = 0;
  SwigClassSecurityID.destroy = (void (*)(void *)) free_FIX_SecurityID;
  SwigClassSecurityID.trackObjects = 0;
  
  SwigClassNoMDEntries.klass = rb_define_class_under(mQuickfix, "NoMDEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMDEntries, (void *) &SwigClassNoMDEntries);
  rb_define_alloc_func(SwigClassNoMDEntries.klass, _wrap_NoMDEntries_allocate);
  rb_define_method(SwigClassNoMDEntries.klass, "initialize", VALUEFUNC(_wrap_new_NoMDEntries), -1);
  SwigClassNoMDEntries.mark = 0;
  SwigClassNoMDEntries.destroy = (void (*)(void *)) free_FIX_NoMDEntries;
  SwigClassNoMDEntries.trackObjects = 0;
  
  SwigClassStrikePriceDeterminationMethod.klass = rb_define_class_under(mQuickfix, "StrikePriceDeterminationMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePriceDeterminationMethod, (void *) &SwigClassStrikePriceDeterminationMethod);
  rb_define_alloc_func(SwigClassStrikePriceDeterminationMethod.klass, _wrap_StrikePriceDeterminationMethod_allocate);
  rb_define_method(SwigClassStrikePriceDeterminationMethod.klass, "initialize", VALUEFUNC(_wrap_new_StrikePriceDeterminationMethod), -1);
  SwigClassStrikePriceDeterminationMethod.mark = 0;
  SwigClassStrikePriceDeterminationMethod.destroy = (void (*)(void *)) free_FIX_StrikePriceDeterminationMethod;
  SwigClassStrikePriceDeterminationMethod.trackObjects = 0;
  
  SwigClassEndDate.klass = rb_define_class_under(mQuickfix, "EndDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndDate, (void *) &SwigClassEndDate);
  rb_define_alloc_func(SwigClassEndDate.klass, _wrap_EndDate_allocate);
  rb_define_method(SwigClassEndDate.klass, "initialize", VALUEFUNC(_wrap_new_EndDate), -1);
  SwigClassEndDate.mark = 0;
  SwigClassEndDate.destroy = (void (*)(void *)) free_FIX_EndDate;
  SwigClassEndDate.trackObjects = 0;
  
  SwigClassCashOutstanding.klass = rb_define_class_under(mQuickfix, "CashOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashOutstanding, (void *) &SwigClassCashOutstanding);
  rb_define_alloc_func(SwigClassCashOutstanding.klass, _wrap_CashOutstanding_allocate);
  rb_define_method(SwigClassCashOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_CashOutstanding), -1);
  SwigClassCashOutstanding.mark = 0;
  SwigClassCashOutstanding.destroy = (void (*)(void *)) free_FIX_CashOutstanding;
  SwigClassCashOutstanding.trackObjects = 0;
  
  SwigClassMDReqID.klass = rb_define_class_under(mQuickfix, "MDReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDReqID, (void *) &SwigClassMDReqID);
  rb_define_alloc_func(SwigClassMDReqID.klass, _wrap_MDReqID_allocate);
  rb_define_method(SwigClassMDReqID.klass, "initialize", VALUEFUNC(_wrap_new_MDReqID), -1);
  SwigClassMDReqID.mark = 0;
  SwigClassMDReqID.destroy = (void (*)(void *)) free_FIX_MDReqID;
  SwigClassMDReqID.trackObjects = 0;
  
  SwigClassIOIRefID.klass = rb_define_class_under(mQuickfix, "IOIRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIRefID, (void *) &SwigClassIOIRefID);
  rb_define_alloc_func(SwigClassIOIRefID.klass, _wrap_IOIRefID_allocate);
  rb_define_method(SwigClassIOIRefID.klass, "initialize", VALUEFUNC(_wrap_new_IOIRefID), -1);
  SwigClassIOIRefID.mark = 0;
  SwigClassIOIRefID.destroy = (void (*)(void *)) free_FIX_IOIRefID;
  SwigClassIOIRefID.trackObjects = 0;
  
  SwigClassTargetStrategy.klass = rb_define_class_under(mQuickfix, "TargetStrategy", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetStrategy, (void *) &SwigClassTargetStrategy);
  rb_define_alloc_func(SwigClassTargetStrategy.klass, _wrap_TargetStrategy_allocate);
  rb_define_method(SwigClassTargetStrategy.klass, "initialize", VALUEFUNC(_wrap_new_TargetStrategy), -1);
  SwigClassTargetStrategy.mark = 0;
  SwigClassTargetStrategy.destroy = (void (*)(void *)) free_FIX_TargetStrategy;
  SwigClassTargetStrategy.trackObjects = 0;
  
  SwigClassConfirmRefID.klass = rb_define_class_under(mQuickfix, "ConfirmRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmRefID, (void *) &SwigClassConfirmRefID);
  rb_define_alloc_func(SwigClassConfirmRefID.klass, _wrap_ConfirmRefID_allocate);
  rb_define_method(SwigClassConfirmRefID.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmRefID), -1);
  SwigClassConfirmRefID.mark = 0;
  SwigClassConfirmRefID.destroy = (void (*)(void *)) free_FIX_ConfirmRefID;
  SwigClassConfirmRefID.trackObjects = 0;
  
  SwigClassSellerDays.klass = rb_define_class_under(mQuickfix, "SellerDays", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SellerDays, (void *) &SwigClassSellerDays);
  rb_define_alloc_func(SwigClassSellerDays.klass, _wrap_SellerDays_allocate);
  rb_define_method(SwigClassSellerDays.klass, "initialize", VALUEFUNC(_wrap_new_SellerDays), -1);
  SwigClassSellerDays.mark = 0;
  SwigClassSellerDays.destroy = (void (*)(void *)) free_FIX_SellerDays;
  SwigClassSellerDays.trackObjects = 0;
  
  SwigClassDueToRelated.klass = rb_define_class_under(mQuickfix, "DueToRelated", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DueToRelated, (void *) &SwigClassDueToRelated);
  rb_define_alloc_func(SwigClassDueToRelated.klass, _wrap_DueToRelated_allocate);
  rb_define_method(SwigClassDueToRelated.klass, "initialize", VALUEFUNC(_wrap_new_DueToRelated), -1);
  SwigClassDueToRelated.mark = 0;
  SwigClassDueToRelated.destroy = (void (*)(void *)) free_FIX_DueToRelated;
  SwigClassDueToRelated.trackObjects = 0;
  
  SwigClassSecondaryTradingReferencePrice.klass = rb_define_class_under(mQuickfix, "SecondaryTradingReferencePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradingReferencePrice, (void *) &SwigClassSecondaryTradingReferencePrice);
  rb_define_alloc_func(SwigClassSecondaryTradingReferencePrice.klass, _wrap_SecondaryTradingReferencePrice_allocate);
  rb_define_method(SwigClassSecondaryTradingReferencePrice.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradingReferencePrice), -1);
  SwigClassSecondaryTradingReferencePrice.mark = 0;
  SwigClassSecondaryTradingReferencePrice.destroy = (void (*)(void *)) free_FIX_SecondaryTradingReferencePrice;
  SwigClassSecondaryTradingReferencePrice.trackObjects = 0;
  
  SwigClassNoMDFeedTypes.klass = rb_define_class_under(mQuickfix, "NoMDFeedTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMDFeedTypes, (void *) &SwigClassNoMDFeedTypes);
  rb_define_alloc_func(SwigClassNoMDFeedTypes.klass, _wrap_NoMDFeedTypes_allocate);
  rb_define_method(SwigClassNoMDFeedTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoMDFeedTypes), -1);
  SwigClassNoMDFeedTypes.mark = 0;
  SwigClassNoMDFeedTypes.destroy = (void (*)(void *)) free_FIX_NoMDFeedTypes;
  SwigClassNoMDFeedTypes.trackObjects = 0;
  
  SwigClassUnderlyingInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType, (void *) &SwigClassUnderlyingInstrumentPartySubIDType);
  rb_define_alloc_func(SwigClassUnderlyingInstrumentPartySubIDType.klass, _wrap_UnderlyingInstrumentPartySubIDType_allocate);
  rb_define_method(SwigClassUnderlyingInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartySubIDType), -1);
  SwigClassUnderlyingInstrumentPartySubIDType.mark = 0;
  SwigClassUnderlyingInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartySubIDType;
  SwigClassUnderlyingInstrumentPartySubIDType.trackObjects = 0;
  
  SwigClassTradSesCloseTime.klass = rb_define_class_under(mQuickfix, "TradSesCloseTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesCloseTime, (void *) &SwigClassTradSesCloseTime);
  rb_define_alloc_func(SwigClassTradSesCloseTime.klass, _wrap_TradSesCloseTime_allocate);
  rb_define_method(SwigClassTradSesCloseTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesCloseTime), -1);
  SwigClassTradSesCloseTime.mark = 0;
  SwigClassTradSesCloseTime.destroy = (void (*)(void *)) free_FIX_TradSesCloseTime;
  SwigClassTradSesCloseTime.trackObjects = 0;
  
  SwigClassContractSettlMonth.klass = rb_define_class_under(mQuickfix, "ContractSettlMonth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContractSettlMonth, (void *) &SwigClassContractSettlMonth);
  rb_define_alloc_func(SwigClassContractSettlMonth.klass, _wrap_ContractSettlMonth_allocate);
  rb_define_method(SwigClassContractSettlMonth.klass, "initialize", VALUEFUNC(_wrap_new_ContractSettlMonth), -1);
  SwigClassContractSettlMonth.mark = 0;
  SwigClassContractSettlMonth.destroy = (void (*)(void *)) free_FIX_ContractSettlMonth;
  SwigClassContractSettlMonth.trackObjects = 0;
  
  SwigClassDerivativeStrikePrice.klass = rb_define_class_under(mQuickfix, "DerivativeStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikePrice, (void *) &SwigClassDerivativeStrikePrice);
  rb_define_alloc_func(SwigClassDerivativeStrikePrice.klass, _wrap_DerivativeStrikePrice_allocate);
  rb_define_method(SwigClassDerivativeStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikePrice), -1);
  SwigClassDerivativeStrikePrice.mark = 0;
  SwigClassDerivativeStrikePrice.destroy = (void (*)(void *)) free_FIX_DerivativeStrikePrice;
  SwigClassDerivativeStrikePrice.trackObjects = 0;
  
  SwigClassTriggerSecurityDesc.klass = rb_define_class_under(mQuickfix, "TriggerSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSecurityDesc, (void *) &SwigClassTriggerSecurityDesc);
  rb_define_alloc_func(SwigClassTriggerSecurityDesc.klass, _wrap_TriggerSecurityDesc_allocate);
  rb_define_method(SwigClassTriggerSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSecurityDesc), -1);
  SwigClassTriggerSecurityDesc.mark = 0;
  SwigClassTriggerSecurityDesc.destroy = (void (*)(void *)) free_FIX_TriggerSecurityDesc;
  SwigClassTriggerSecurityDesc.trackObjects = 0;
  
  SwigClassUnderlyingCashType.klass = rb_define_class_under(mQuickfix, "UnderlyingCashType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCashType, (void *) &SwigClassUnderlyingCashType);
  rb_define_alloc_func(SwigClassUnderlyingCashType.klass, _wrap_UnderlyingCashType_allocate);
  rb_define_method(SwigClassUnderlyingCashType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCashType), -1);
  SwigClassUnderlyingCashType.mark = 0;
  SwigClassUnderlyingCashType.destroy = (void (*)(void *)) free_FIX_UnderlyingCashType;
  SwigClassUnderlyingCashType.trackObjects = 0;
  
  SwigClassNoMiscFees.klass = rb_define_class_under(mQuickfix, "NoMiscFees", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMiscFees, (void *) &SwigClassNoMiscFees);
  rb_define_alloc_func(SwigClassNoMiscFees.klass, _wrap_NoMiscFees_allocate);
  rb_define_method(SwigClassNoMiscFees.klass, "initialize", VALUEFUNC(_wrap_new_NoMiscFees), -1);
  SwigClassNoMiscFees.mark = 0;
  SwigClassNoMiscFees.destroy = (void (*)(void *)) free_FIX_NoMiscFees;
  SwigClassNoMiscFees.trackObjects = 0;
  
  SwigClassCustOrderCapacity.klass = rb_define_class_under(mQuickfix, "CustOrderCapacity", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustOrderCapacity, (void *) &SwigClassCustOrderCapacity);
  rb_define_alloc_func(SwigClassCustOrderCapacity.klass, _wrap_CustOrderCapacity_allocate);
  rb_define_method(SwigClassCustOrderCapacity.klass, "initialize", VALUEFUNC(_wrap_new_CustOrderCapacity), -1);
  SwigClassCustOrderCapacity.mark = 0;
  SwigClassCustOrderCapacity.destroy = (void (*)(void *)) free_FIX_CustOrderCapacity;
  SwigClassCustOrderCapacity.trackObjects = 0;
  
  SwigClassLegAllocSettlCurrency.klass = rb_define_class_under(mQuickfix, "LegAllocSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocSettlCurrency, (void *) &SwigClassLegAllocSettlCurrency);
  rb_define_alloc_func(SwigClassLegAllocSettlCurrency.klass, _wrap_LegAllocSettlCurrency_allocate);
  rb_define_method(SwigClassLegAllocSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocSettlCurrency), -1);
  SwigClassLegAllocSettlCurrency.mark = 0;
  SwigClassLegAllocSettlCurrency.destroy = (void (*)(void *)) free_FIX_LegAllocSettlCurrency;
  SwigClassLegAllocSettlCurrency.trackObjects = 0;
  
  SwigClassUnderlyingAdjustedQuantity.klass = rb_define_class_under(mQuickfix, "UnderlyingAdjustedQuantity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity, (void *) &SwigClassUnderlyingAdjustedQuantity);
  rb_define_alloc_func(SwigClassUnderlyingAdjustedQuantity.klass, _wrap_UnderlyingAdjustedQuantity_allocate);
  rb_define_method(SwigClassUnderlyingAdjustedQuantity.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingAdjustedQuantity), -1);
  SwigClassUnderlyingAdjustedQuantity.mark = 0;
  SwigClassUnderlyingAdjustedQuantity.destroy = (void (*)(void *)) free_FIX_UnderlyingAdjustedQuantity;
  SwigClassUnderlyingAdjustedQuantity.trackObjects = 0;
  
  SwigClassOwnershipType.klass = rb_define_class_under(mQuickfix, "OwnershipType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OwnershipType, (void *) &SwigClassOwnershipType);
  rb_define_alloc_func(SwigClassOwnershipType.klass, _wrap_OwnershipType_allocate);
  rb_define_method(SwigClassOwnershipType.klass, "initialize", VALUEFUNC(_wrap_new_OwnershipType), -1);
  SwigClassOwnershipType.mark = 0;
  SwigClassOwnershipType.destroy = (void (*)(void *)) free_FIX_OwnershipType;
  SwigClassOwnershipType.trackObjects = 0;
  
  SwigClassMaxShow.klass = rb_define_class_under(mQuickfix, "MaxShow", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxShow, (void *) &SwigClassMaxShow);
  rb_define_alloc_func(SwigClassMaxShow.klass, _wrap_MaxShow_allocate);
  rb_define_method(SwigClassMaxShow.klass, "initialize", VALUEFUNC(_wrap_new_MaxShow), -1);
  SwigClassMaxShow.mark = 0;
  SwigClassMaxShow.destroy = (void (*)(void *)) free_FIX_MaxShow;
  SwigClassMaxShow.trackObjects = 0;
  
  SwigClassLegSecurityID.klass = rb_define_class_under(mQuickfix, "LegSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityID, (void *) &SwigClassLegSecurityID);
  rb_define_alloc_func(SwigClassLegSecurityID.klass, _wrap_LegSecurityID_allocate);
  rb_define_method(SwigClassLegSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityID), -1);
  SwigClassLegSecurityID.mark = 0;
  SwigClassLegSecurityID.destroy = (void (*)(void *)) free_FIX_LegSecurityID;
  SwigClassLegSecurityID.trackObjects = 0;
  
  SwigClassDerivativeSecurityDesc.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityDesc, (void *) &SwigClassDerivativeSecurityDesc);
  rb_define_alloc_func(SwigClassDerivativeSecurityDesc.klass, _wrap_DerivativeSecurityDesc_allocate);
  rb_define_method(SwigClassDerivativeSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityDesc), -1);
  SwigClassDerivativeSecurityDesc.mark = 0;
  SwigClassDerivativeSecurityDesc.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityDesc;
  SwigClassDerivativeSecurityDesc.trackObjects = 0;
  
  SwigClassUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "UnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnitOfMeasure, (void *) &SwigClassUnitOfMeasure);
  rb_define_alloc_func(SwigClassUnitOfMeasure.klass, _wrap_UnitOfMeasure_allocate);
  rb_define_method(SwigClassUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_UnitOfMeasure), -1);
  SwigClassUnitOfMeasure.mark = 0;
  SwigClassUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_UnitOfMeasure;
  SwigClassUnitOfMeasure.trackObjects = 0;
  
  SwigClassQuantity.klass = rb_define_class_under(mQuickfix, "Quantity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Quantity, (void *) &SwigClassQuantity);
  rb_define_alloc_func(SwigClassQuantity.klass, _wrap_Quantity_allocate);
  rb_define_method(SwigClassQuantity.klass, "initialize", VALUEFUNC(_wrap_new_Quantity), -1);
  SwigClassQuantity.mark = 0;
  SwigClassQuantity.destroy = (void (*)(void *)) free_FIX_Quantity;
  SwigClassQuantity.trackObjects = 0;
  
  SwigClassNewsID.klass = rb_define_class_under(mQuickfix, "NewsID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsID, (void *) &SwigClassNewsID);
  rb_define_alloc_func(SwigClassNewsID.klass, _wrap_NewsID_allocate);
  rb_define_method(SwigClassNewsID.klass, "initialize", VALUEFUNC(_wrap_new_NewsID), -1);
  SwigClassNewsID.mark = 0;
  SwigClassNewsID.destroy = (void (*)(void *)) free_FIX_NewsID;
  SwigClassNewsID.trackObjects = 0;
  
  SwigClassUndlyInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType, (void *) &SwigClassUndlyInstrumentPartySubIDType);
  rb_define_alloc_func(SwigClassUndlyInstrumentPartySubIDType.klass, _wrap_UndlyInstrumentPartySubIDType_allocate);
  rb_define_method(SwigClassUndlyInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartySubIDType), -1);
  SwigClassUndlyInstrumentPartySubIDType.mark = 0;
  SwigClassUndlyInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartySubIDType;
  SwigClassUndlyInstrumentPartySubIDType.trackObjects = 0;
  
  SwigClassSettleOnOpenFlag.klass = rb_define_class_under(mQuickfix, "SettleOnOpenFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettleOnOpenFlag, (void *) &SwigClassSettleOnOpenFlag);
  rb_define_alloc_func(SwigClassSettleOnOpenFlag.klass, _wrap_SettleOnOpenFlag_allocate);
  rb_define_method(SwigClassSettleOnOpenFlag.klass, "initialize", VALUEFUNC(_wrap_new_SettleOnOpenFlag), -1);
  SwigClassSettleOnOpenFlag.mark = 0;
  SwigClassSettleOnOpenFlag.destroy = (void (*)(void *)) free_FIX_SettleOnOpenFlag;
  SwigClassSettleOnOpenFlag.trackObjects = 0;
  
  SwigClassLastUpdateTime.klass = rb_define_class_under(mQuickfix, "LastUpdateTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastUpdateTime, (void *) &SwigClassLastUpdateTime);
  rb_define_alloc_func(SwigClassLastUpdateTime.klass, _wrap_LastUpdateTime_allocate);
  rb_define_method(SwigClassLastUpdateTime.klass, "initialize", VALUEFUNC(_wrap_new_LastUpdateTime), -1);
  SwigClassLastUpdateTime.mark = 0;
  SwigClassLastUpdateTime.destroy = (void (*)(void *)) free_FIX_LastUpdateTime;
  SwigClassLastUpdateTime.trackObjects = 0;
  
  SwigClassRepurchaseRate.klass = rb_define_class_under(mQuickfix, "RepurchaseRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepurchaseRate, (void *) &SwigClassRepurchaseRate);
  rb_define_alloc_func(SwigClassRepurchaseRate.klass, _wrap_RepurchaseRate_allocate);
  rb_define_method(SwigClassRepurchaseRate.klass, "initialize", VALUEFUNC(_wrap_new_RepurchaseRate), -1);
  SwigClassRepurchaseRate.mark = 0;
  SwigClassRepurchaseRate.destroy = (void (*)(void *)) free_FIX_RepurchaseRate;
  SwigClassRepurchaseRate.trackObjects = 0;
  
  SwigClassRepurchaseTerm.klass = rb_define_class_under(mQuickfix, "RepurchaseTerm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepurchaseTerm, (void *) &SwigClassRepurchaseTerm);
  rb_define_alloc_func(SwigClassRepurchaseTerm.klass, _wrap_RepurchaseTerm_allocate);
  rb_define_method(SwigClassRepurchaseTerm.klass, "initialize", VALUEFUNC(_wrap_new_RepurchaseTerm), -1);
  SwigClassRepurchaseTerm.mark = 0;
  SwigClassRepurchaseTerm.destroy = (void (*)(void *)) free_FIX_RepurchaseTerm;
  SwigClassRepurchaseTerm.trackObjects = 0;
  
  SwigClassNestedPartyRole.klass = rb_define_class_under(mQuickfix, "NestedPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartyRole, (void *) &SwigClassNestedPartyRole);
  rb_define_alloc_func(SwigClassNestedPartyRole.klass, _wrap_NestedPartyRole_allocate);
  rb_define_method(SwigClassNestedPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartyRole), -1);
  SwigClassNestedPartyRole.mark = 0;
  SwigClassNestedPartyRole.destroy = (void (*)(void *)) free_FIX_NestedPartyRole;
  SwigClassNestedPartyRole.trackObjects = 0;
  
  SwigClassSecondaryExecID.klass = rb_define_class_under(mQuickfix, "SecondaryExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryExecID, (void *) &SwigClassSecondaryExecID);
  rb_define_alloc_func(SwigClassSecondaryExecID.klass, _wrap_SecondaryExecID_allocate);
  rb_define_method(SwigClassSecondaryExecID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryExecID), -1);
  SwigClassSecondaryExecID.mark = 0;
  SwigClassSecondaryExecID.destroy = (void (*)(void *)) free_FIX_SecondaryExecID;
  SwigClassSecondaryExecID.trackObjects = 0;
  
  SwigClassPool.klass = rb_define_class_under(mQuickfix, "Pool", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Pool, (void *) &SwigClassPool);
  rb_define_alloc_func(SwigClassPool.klass, _wrap_Pool_allocate);
  rb_define_method(SwigClassPool.klass, "initialize", VALUEFUNC(_wrap_new_Pool), -1);
  SwigClassPool.mark = 0;
  SwigClassPool.destroy = (void (*)(void *)) free_FIX_Pool;
  SwigClassPool.trackObjects = 0;
  
  SwigClassNoTickRules.klass = rb_define_class_under(mQuickfix, "NoTickRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTickRules, (void *) &SwigClassNoTickRules);
  rb_define_alloc_func(SwigClassNoTickRules.klass, _wrap_NoTickRules_allocate);
  rb_define_method(SwigClassNoTickRules.klass, "initialize", VALUEFUNC(_wrap_new_NoTickRules), -1);
  SwigClassNoTickRules.mark = 0;
  SwigClassNoTickRules.destroy = (void (*)(void *)) free_FIX_NoTickRules;
  SwigClassNoTickRules.trackObjects = 0;
  
  SwigClassVolatility.klass = rb_define_class_under(mQuickfix, "Volatility", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Volatility, (void *) &SwigClassVolatility);
  rb_define_alloc_func(SwigClassVolatility.klass, _wrap_Volatility_allocate);
  rb_define_method(SwigClassVolatility.klass, "initialize", VALUEFUNC(_wrap_new_Volatility), -1);
  SwigClassVolatility.mark = 0;
  SwigClassVolatility.destroy = (void (*)(void *)) free_FIX_Volatility;
  SwigClassVolatility.trackObjects = 0;
  
  SwigClassPctAtRisk.klass = rb_define_class_under(mQuickfix, "PctAtRisk", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PctAtRisk, (void *) &SwigClassPctAtRisk);
  rb_define_alloc_func(SwigClassPctAtRisk.klass, _wrap_PctAtRisk_allocate);
  rb_define_method(SwigClassPctAtRisk.klass, "initialize", VALUEFUNC(_wrap_new_PctAtRisk), -1);
  SwigClassPctAtRisk.mark = 0;
  SwigClassPctAtRisk.destroy = (void (*)(void *)) free_FIX_PctAtRisk;
  SwigClassPctAtRisk.trackObjects = 0;
  
  SwigClassUnderlyingSecurityExchange.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityExchange, (void *) &SwigClassUnderlyingSecurityExchange);
  rb_define_alloc_func(SwigClassUnderlyingSecurityExchange.klass, _wrap_UnderlyingSecurityExchange_allocate);
  rb_define_method(SwigClassUnderlyingSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityExchange), -1);
  SwigClassUnderlyingSecurityExchange.mark = 0;
  SwigClassUnderlyingSecurityExchange.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityExchange;
  SwigClassUnderlyingSecurityExchange.trackObjects = 0;
  
  SwigClassLegStrikePrice.klass = rb_define_class_under(mQuickfix, "LegStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStrikePrice, (void *) &SwigClassLegStrikePrice);
  rb_define_alloc_func(SwigClassLegStrikePrice.klass, _wrap_LegStrikePrice_allocate);
  rb_define_method(SwigClassLegStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_LegStrikePrice), -1);
  SwigClassLegStrikePrice.mark = 0;
  SwigClassLegStrikePrice.destroy = (void (*)(void *)) free_FIX_LegStrikePrice;
  SwigClassLegStrikePrice.trackObjects = 0;
  
  SwigClassSettlmntTyp.klass = rb_define_class_under(mQuickfix, "SettlmntTyp", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlmntTyp, (void *) &SwigClassSettlmntTyp);
  rb_define_alloc_func(SwigClassSettlmntTyp.klass, _wrap_SettlmntTyp_allocate);
  rb_define_method(SwigClassSettlmntTyp.klass, "initialize", VALUEFUNC(_wrap_new_SettlmntTyp), -1);
  SwigClassSettlmntTyp.mark = 0;
  SwigClassSettlmntTyp.destroy = (void (*)(void *)) free_FIX_SettlmntTyp;
  SwigClassSettlmntTyp.trackObjects = 0;
  
  SwigClassTradePublishIndicator.klass = rb_define_class_under(mQuickfix, "TradePublishIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradePublishIndicator, (void *) &SwigClassTradePublishIndicator);
  rb_define_alloc_func(SwigClassTradePublishIndicator.klass, _wrap_TradePublishIndicator_allocate);
  rb_define_method(SwigClassTradePublishIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TradePublishIndicator), -1);
  SwigClassTradePublishIndicator.mark = 0;
  SwigClassTradePublishIndicator.destroy = (void (*)(void *)) free_FIX_TradePublishIndicator;
  SwigClassTradePublishIndicator.trackObjects = 0;
  
  SwigClassApplResponseType.klass = rb_define_class_under(mQuickfix, "ApplResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResponseType, (void *) &SwigClassApplResponseType);
  rb_define_alloc_func(SwigClassApplResponseType.klass, _wrap_ApplResponseType_allocate);
  rb_define_method(SwigClassApplResponseType.klass, "initialize", VALUEFUNC(_wrap_new_ApplResponseType), -1);
  SwigClassApplResponseType.mark = 0;
  SwigClassApplResponseType.destroy = (void (*)(void *)) free_FIX_ApplResponseType;
  SwigClassApplResponseType.trackObjects = 0;
  
  SwigClassMDSubBookType.klass = rb_define_class_under(mQuickfix, "MDSubBookType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDSubBookType, (void *) &SwigClassMDSubBookType);
  rb_define_alloc_func(SwigClassMDSubBookType.klass, _wrap_MDSubBookType_allocate);
  rb_define_method(SwigClassMDSubBookType.klass, "initialize", VALUEFUNC(_wrap_new_MDSubBookType), -1);
  SwigClassMDSubBookType.mark = 0;
  SwigClassMDSubBookType.destroy = (void (*)(void *)) free_FIX_MDSubBookType;
  SwigClassMDSubBookType.trackObjects = 0;
  
  SwigClassUsername.klass = rb_define_class_under(mQuickfix, "Username", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Username, (void *) &SwigClassUsername);
  rb_define_alloc_func(SwigClassUsername.klass, _wrap_Username_allocate);
  rb_define_method(SwigClassUsername.klass, "initialize", VALUEFUNC(_wrap_new_Username), -1);
  SwigClassUsername.mark = 0;
  SwigClassUsername.destroy = (void (*)(void *)) free_FIX_Username;
  SwigClassUsername.trackObjects = 0;
  
  SwigClassStandInstDbType.klass = rb_define_class_under(mQuickfix, "StandInstDbType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StandInstDbType, (void *) &SwigClassStandInstDbType);
  rb_define_alloc_func(SwigClassStandInstDbType.klass, _wrap_StandInstDbType_allocate);
  rb_define_method(SwigClassStandInstDbType.klass, "initialize", VALUEFUNC(_wrap_new_StandInstDbType), -1);
  SwigClassStandInstDbType.mark = 0;
  SwigClassStandInstDbType.destroy = (void (*)(void *)) free_FIX_StandInstDbType;
  SwigClassStandInstDbType.trackObjects = 0;
  
  SwigClassQuoteEntryStatus.klass = rb_define_class_under(mQuickfix, "QuoteEntryStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteEntryStatus, (void *) &SwigClassQuoteEntryStatus);
  rb_define_alloc_func(SwigClassQuoteEntryStatus.klass, _wrap_QuoteEntryStatus_allocate);
  rb_define_method(SwigClassQuoteEntryStatus.klass, "initialize", VALUEFUNC(_wrap_new_QuoteEntryStatus), -1);
  SwigClassQuoteEntryStatus.mark = 0;
  SwigClassQuoteEntryStatus.destroy = (void (*)(void *)) free_FIX_QuoteEntryStatus;
  SwigClassQuoteEntryStatus.trackObjects = 0;
  
  SwigClassTriggerPriceType.klass = rb_define_class_under(mQuickfix, "TriggerPriceType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPriceType, (void *) &SwigClassTriggerPriceType);
  rb_define_alloc_func(SwigClassTriggerPriceType.klass, _wrap_TriggerPriceType_allocate);
  rb_define_method(SwigClassTriggerPriceType.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPriceType), -1);
  SwigClassTriggerPriceType.mark = 0;
  SwigClassTriggerPriceType.destroy = (void (*)(void *)) free_FIX_TriggerPriceType;
  SwigClassTriggerPriceType.trackObjects = 0;
  
  SwigClassSideTrdSubTyp.klass = rb_define_class_under(mQuickfix, "SideTrdSubTyp", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdSubTyp, (void *) &SwigClassSideTrdSubTyp);
  rb_define_alloc_func(SwigClassSideTrdSubTyp.klass, _wrap_SideTrdSubTyp_allocate);
  rb_define_method(SwigClassSideTrdSubTyp.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdSubTyp), -1);
  SwigClassSideTrdSubTyp.mark = 0;
  SwigClassSideTrdSubTyp.destroy = (void (*)(void *)) free_FIX_SideTrdSubTyp;
  SwigClassSideTrdSubTyp.trackObjects = 0;
  
  SwigClassUnderlyingTradingSessionSubID.klass = rb_define_class_under(mQuickfix, "UnderlyingTradingSessionSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID, (void *) &SwigClassUnderlyingTradingSessionSubID);
  rb_define_alloc_func(SwigClassUnderlyingTradingSessionSubID.klass, _wrap_UnderlyingTradingSessionSubID_allocate);
  rb_define_method(SwigClassUnderlyingTradingSessionSubID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingTradingSessionSubID), -1);
  SwigClassUnderlyingTradingSessionSubID.mark = 0;
  SwigClassUnderlyingTradingSessionSubID.destroy = (void (*)(void *)) free_FIX_UnderlyingTradingSessionSubID;
  SwigClassUnderlyingTradingSessionSubID.trackObjects = 0;
  
  SwigClassSettlInstReqRejCode.klass = rb_define_class_under(mQuickfix, "SettlInstReqRejCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstReqRejCode, (void *) &SwigClassSettlInstReqRejCode);
  rb_define_alloc_func(SwigClassSettlInstReqRejCode.klass, _wrap_SettlInstReqRejCode_allocate);
  rb_define_method(SwigClassSettlInstReqRejCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstReqRejCode), -1);
  SwigClassSettlInstReqRejCode.mark = 0;
  SwigClassSettlInstReqRejCode.destroy = (void (*)(void *)) free_FIX_SettlInstReqRejCode;
  SwigClassSettlInstReqRejCode.trackObjects = 0;
  
  SwigClassMktBidPx.klass = rb_define_class_under(mQuickfix, "MktBidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MktBidPx, (void *) &SwigClassMktBidPx);
  rb_define_alloc_func(SwigClassMktBidPx.klass, _wrap_MktBidPx_allocate);
  rb_define_method(SwigClassMktBidPx.klass, "initialize", VALUEFUNC(_wrap_new_MktBidPx), -1);
  SwigClassMktBidPx.mark = 0;
  SwigClassMktBidPx.destroy = (void (*)(void *)) free_FIX_MktBidPx;
  SwigClassMktBidPx.trackObjects = 0;
  
  SwigClassUnderlyingLegSymbol.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSymbol, (void *) &SwigClassUnderlyingLegSymbol);
  rb_define_alloc_func(SwigClassUnderlyingLegSymbol.klass, _wrap_UnderlyingLegSymbol_allocate);
  rb_define_method(SwigClassUnderlyingLegSymbol.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSymbol), -1);
  SwigClassUnderlyingLegSymbol.mark = 0;
  SwigClassUnderlyingLegSymbol.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSymbol;
  SwigClassUnderlyingLegSymbol.trackObjects = 0;
  
  SwigClassStrikeValue.klass = rb_define_class_under(mQuickfix, "StrikeValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeValue, (void *) &SwigClassStrikeValue);
  rb_define_alloc_func(SwigClassStrikeValue.klass, _wrap_StrikeValue_allocate);
  rb_define_method(SwigClassStrikeValue.klass, "initialize", VALUEFUNC(_wrap_new_StrikeValue), -1);
  SwigClassStrikeValue.mark = 0;
  SwigClassStrikeValue.destroy = (void (*)(void *)) free_FIX_StrikeValue;
  SwigClassStrikeValue.trackObjects = 0;
  
  SwigClassUrgency.klass = rb_define_class_under(mQuickfix, "Urgency", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Urgency, (void *) &SwigClassUrgency);
  rb_define_alloc_func(SwigClassUrgency.klass, _wrap_Urgency_allocate);
  rb_define_method(SwigClassUrgency.klass, "initialize", VALUEFUNC(_wrap_new_Urgency), -1);
  SwigClassUrgency.mark = 0;
  SwigClassUrgency.destroy = (void (*)(void *)) free_FIX_Urgency;
  SwigClassUrgency.trackObjects = 0;
  
  SwigClassAllocID.klass = rb_define_class_under(mQuickfix, "AllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocID, (void *) &SwigClassAllocID);
  rb_define_alloc_func(SwigClassAllocID.klass, _wrap_AllocID_allocate);
  rb_define_method(SwigClassAllocID.klass, "initialize", VALUEFUNC(_wrap_new_AllocID), -1);
  SwigClassAllocID.mark = 0;
  SwigClassAllocID.destroy = (void (*)(void *)) free_FIX_AllocID;
  SwigClassAllocID.trackObjects = 0;
  
  SwigClassUnderlyingDeliveryAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingDeliveryAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingDeliveryAmount, (void *) &SwigClassUnderlyingDeliveryAmount);
  rb_define_alloc_func(SwigClassUnderlyingDeliveryAmount.klass, _wrap_UnderlyingDeliveryAmount_allocate);
  rb_define_method(SwigClassUnderlyingDeliveryAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingDeliveryAmount), -1);
  SwigClassUnderlyingDeliveryAmount.mark = 0;
  SwigClassUnderlyingDeliveryAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingDeliveryAmount;
  SwigClassUnderlyingDeliveryAmount.trackObjects = 0;
  
  SwigClassSideQty.klass = rb_define_class_under(mQuickfix, "SideQty", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideQty, (void *) &SwigClassSideQty);
  rb_define_alloc_func(SwigClassSideQty.klass, _wrap_SideQty_allocate);
  rb_define_method(SwigClassSideQty.klass, "initialize", VALUEFUNC(_wrap_new_SideQty), -1);
  SwigClassSideQty.mark = 0;
  SwigClassSideQty.destroy = (void (*)(void *)) free_FIX_SideQty;
  SwigClassSideQty.trackObjects = 0;
  
  SwigClassCollAsgnTransType.klass = rb_define_class_under(mQuickfix, "CollAsgnTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnTransType, (void *) &SwigClassCollAsgnTransType);
  rb_define_alloc_func(SwigClassCollAsgnTransType.klass, _wrap_CollAsgnTransType_allocate);
  rb_define_method(SwigClassCollAsgnTransType.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnTransType), -1);
  SwigClassCollAsgnTransType.mark = 0;
  SwigClassCollAsgnTransType.destroy = (void (*)(void *)) free_FIX_CollAsgnTransType;
  SwigClassCollAsgnTransType.trackObjects = 0;
  
  SwigClassThresholdAmount.klass = rb_define_class_under(mQuickfix, "ThresholdAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ThresholdAmount, (void *) &SwigClassThresholdAmount);
  rb_define_alloc_func(SwigClassThresholdAmount.klass, _wrap_ThresholdAmount_allocate);
  rb_define_method(SwigClassThresholdAmount.klass, "initialize", VALUEFUNC(_wrap_new_ThresholdAmount), -1);
  SwigClassThresholdAmount.mark = 0;
  SwigClassThresholdAmount.destroy = (void (*)(void *)) free_FIX_ThresholdAmount;
  SwigClassThresholdAmount.trackObjects = 0;
  
  SwigClassDefBidSize.klass = rb_define_class_under(mQuickfix, "DefBidSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefBidSize, (void *) &SwigClassDefBidSize);
  rb_define_alloc_func(SwigClassDefBidSize.klass, _wrap_DefBidSize_allocate);
  rb_define_method(SwigClassDefBidSize.klass, "initialize", VALUEFUNC(_wrap_new_DefBidSize), -1);
  SwigClassDefBidSize.mark = 0;
  SwigClassDefBidSize.destroy = (void (*)(void *)) free_FIX_DefBidSize;
  SwigClassDefBidSize.trackObjects = 0;
  
  SwigClassLegStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "LegStateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue, (void *) &SwigClassLegStateOrProvinceOfIssue);
  rb_define_alloc_func(SwigClassLegStateOrProvinceOfIssue.klass, _wrap_LegStateOrProvinceOfIssue_allocate);
  rb_define_method(SwigClassLegStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LegStateOrProvinceOfIssue), -1);
  SwigClassLegStateOrProvinceOfIssue.mark = 0;
  SwigClassLegStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_LegStateOrProvinceOfIssue;
  SwigClassLegStateOrProvinceOfIssue.trackObjects = 0;
  
  SwigClassPaymentMethod.klass = rb_define_class_under(mQuickfix, "PaymentMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentMethod, (void *) &SwigClassPaymentMethod);
  rb_define_alloc_func(SwigClassPaymentMethod.klass, _wrap_PaymentMethod_allocate);
  rb_define_method(SwigClassPaymentMethod.klass, "initialize", VALUEFUNC(_wrap_new_PaymentMethod), -1);
  SwigClassPaymentMethod.mark = 0;
  SwigClassPaymentMethod.destroy = (void (*)(void *)) free_FIX_PaymentMethod;
  SwigClassPaymentMethod.trackObjects = 0;
  
  SwigClassUnderlyingLegOptAttribute.klass = rb_define_class_under(mQuickfix, "UnderlyingLegOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegOptAttribute, (void *) &SwigClassUnderlyingLegOptAttribute);
  rb_define_alloc_func(SwigClassUnderlyingLegOptAttribute.klass, _wrap_UnderlyingLegOptAttribute_allocate);
  rb_define_method(SwigClassUnderlyingLegOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegOptAttribute), -1);
  SwigClassUnderlyingLegOptAttribute.mark = 0;
  SwigClassUnderlyingLegOptAttribute.destroy = (void (*)(void *)) free_FIX_UnderlyingLegOptAttribute;
  SwigClassUnderlyingLegOptAttribute.trackObjects = 0;
  
  SwigClassLegVolatility.klass = rb_define_class_under(mQuickfix, "LegVolatility", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegVolatility, (void *) &SwigClassLegVolatility);
  rb_define_alloc_func(SwigClassLegVolatility.klass, _wrap_LegVolatility_allocate);
  rb_define_method(SwigClassLegVolatility.klass, "initialize", VALUEFUNC(_wrap_new_LegVolatility), -1);
  SwigClassLegVolatility.mark = 0;
  SwigClassLegVolatility.destroy = (void (*)(void *)) free_FIX_LegVolatility;
  SwigClassLegVolatility.trackObjects = 0;
  
  SwigClassDerivativeInstrAttribType.klass = rb_define_class_under(mQuickfix, "DerivativeInstrAttribType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrAttribType, (void *) &SwigClassDerivativeInstrAttribType);
  rb_define_alloc_func(SwigClassDerivativeInstrAttribType.klass, _wrap_DerivativeInstrAttribType_allocate);
  rb_define_method(SwigClassDerivativeInstrAttribType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrAttribType), -1);
  SwigClassDerivativeInstrAttribType.mark = 0;
  SwigClassDerivativeInstrAttribType.destroy = (void (*)(void *)) free_FIX_DerivativeInstrAttribType;
  SwigClassDerivativeInstrAttribType.trackObjects = 0;
  
  SwigClassDerivativeUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "DerivativeUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty, (void *) &SwigClassDerivativeUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassDerivativeUnitOfMeasureQty.klass, _wrap_DerivativeUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassDerivativeUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeUnitOfMeasureQty), -1);
  SwigClassDerivativeUnitOfMeasureQty.mark = 0;
  SwigClassDerivativeUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_DerivativeUnitOfMeasureQty;
  SwigClassDerivativeUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassNoStatsIndicators.klass = rb_define_class_under(mQuickfix, "NoStatsIndicators", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStatsIndicators, (void *) &SwigClassNoStatsIndicators);
  rb_define_alloc_func(SwigClassNoStatsIndicators.klass, _wrap_NoStatsIndicators_allocate);
  rb_define_method(SwigClassNoStatsIndicators.klass, "initialize", VALUEFUNC(_wrap_new_NoStatsIndicators), -1);
  SwigClassNoStatsIndicators.mark = 0;
  SwigClassNoStatsIndicators.destroy = (void (*)(void *)) free_FIX_NoStatsIndicators;
  SwigClassNoStatsIndicators.trackObjects = 0;
  
  SwigClassTriggerPriceTypeScope.klass = rb_define_class_under(mQuickfix, "TriggerPriceTypeScope", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPriceTypeScope, (void *) &SwigClassTriggerPriceTypeScope);
  rb_define_alloc_func(SwigClassTriggerPriceTypeScope.klass, _wrap_TriggerPriceTypeScope_allocate);
  rb_define_method(SwigClassTriggerPriceTypeScope.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPriceTypeScope), -1);
  SwigClassTriggerPriceTypeScope.mark = 0;
  SwigClassTriggerPriceTypeScope.destroy = (void (*)(void *)) free_FIX_TriggerPriceTypeScope;
  SwigClassTriggerPriceTypeScope.trackObjects = 0;
  
  SwigClassLastNetworkResponseID.klass = rb_define_class_under(mQuickfix, "LastNetworkResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastNetworkResponseID, (void *) &SwigClassLastNetworkResponseID);
  rb_define_alloc_func(SwigClassLastNetworkResponseID.klass, _wrap_LastNetworkResponseID_allocate);
  rb_define_method(SwigClassLastNetworkResponseID.klass, "initialize", VALUEFUNC(_wrap_new_LastNetworkResponseID), -1);
  SwigClassLastNetworkResponseID.mark = 0;
  SwigClassLastNetworkResponseID.destroy = (void (*)(void *)) free_FIX_LastNetworkResponseID;
  SwigClassLastNetworkResponseID.trackObjects = 0;
  
  SwigClassUnderlyingSettlPriceType.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlPriceType, (void *) &SwigClassUnderlyingSettlPriceType);
  rb_define_alloc_func(SwigClassUnderlyingSettlPriceType.klass, _wrap_UnderlyingSettlPriceType_allocate);
  rb_define_method(SwigClassUnderlyingSettlPriceType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlPriceType), -1);
  SwigClassUnderlyingSettlPriceType.mark = 0;
  SwigClassUnderlyingSettlPriceType.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlPriceType;
  SwigClassUnderlyingSettlPriceType.trackObjects = 0;
  
  SwigClassApplReportID.klass = rb_define_class_under(mQuickfix, "ApplReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReportID, (void *) &SwigClassApplReportID);
  rb_define_alloc_func(SwigClassApplReportID.klass, _wrap_ApplReportID_allocate);
  rb_define_method(SwigClassApplReportID.klass, "initialize", VALUEFUNC(_wrap_new_ApplReportID), -1);
  SwigClassApplReportID.mark = 0;
  SwigClassApplReportID.destroy = (void (*)(void *)) free_FIX_ApplReportID;
  SwigClassApplReportID.trackObjects = 0;
  
  SwigClassPegLimitType.klass = rb_define_class_under(mQuickfix, "PegLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegLimitType, (void *) &SwigClassPegLimitType);
  rb_define_alloc_func(SwigClassPegLimitType.klass, _wrap_PegLimitType_allocate);
  rb_define_method(SwigClassPegLimitType.klass, "initialize", VALUEFUNC(_wrap_new_PegLimitType), -1);
  SwigClassPegLimitType.mark = 0;
  SwigClassPegLimitType.destroy = (void (*)(void *)) free_FIX_PegLimitType;
  SwigClassPegLimitType.trackObjects = 0;
  
  SwigClassExecID.klass = rb_define_class_under(mQuickfix, "ExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecID, (void *) &SwigClassExecID);
  rb_define_alloc_func(SwigClassExecID.klass, _wrap_ExecID_allocate);
  rb_define_method(SwigClassExecID.klass, "initialize", VALUEFUNC(_wrap_new_ExecID), -1);
  SwigClassExecID.mark = 0;
  SwigClassExecID.destroy = (void (*)(void *)) free_FIX_ExecID;
  SwigClassExecID.trackObjects = 0;
  
  SwigClassSide.klass = rb_define_class_under(mQuickfix, "Side", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Side, (void *) &SwigClassSide);
  rb_define_alloc_func(SwigClassSide.klass, _wrap_Side_allocate);
  rb_define_method(SwigClassSide.klass, "initialize", VALUEFUNC(_wrap_new_Side), -1);
  SwigClassSide.mark = 0;
  SwigClassSide.destroy = (void (*)(void *)) free_FIX_Side;
  SwigClassSide.trackObjects = 0;
  
  SwigClassUnderlyingLastPx.klass = rb_define_class_under(mQuickfix, "UnderlyingLastPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLastPx, (void *) &SwigClassUnderlyingLastPx);
  rb_define_alloc_func(SwigClassUnderlyingLastPx.klass, _wrap_UnderlyingLastPx_allocate);
  rb_define_method(SwigClassUnderlyingLastPx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLastPx), -1);
  SwigClassUnderlyingLastPx.mark = 0;
  SwigClassUnderlyingLastPx.destroy = (void (*)(void *)) free_FIX_UnderlyingLastPx;
  SwigClassUnderlyingLastPx.trackObjects = 0;
  
  SwigClassMarketDepth.klass = rb_define_class_under(mQuickfix, "MarketDepth", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketDepth, (void *) &SwigClassMarketDepth);
  rb_define_alloc_func(SwigClassMarketDepth.klass, _wrap_MarketDepth_allocate);
  rb_define_method(SwigClassMarketDepth.klass, "initialize", VALUEFUNC(_wrap_new_MarketDepth), -1);
  SwigClassMarketDepth.mark = 0;
  SwigClassMarketDepth.destroy = (void (*)(void *)) free_FIX_MarketDepth;
  SwigClassMarketDepth.trackObjects = 0;
  
  SwigClassDiscretionOffset.klass = rb_define_class_under(mQuickfix, "DiscretionOffset", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionOffset, (void *) &SwigClassDiscretionOffset);
  rb_define_alloc_func(SwigClassDiscretionOffset.klass, _wrap_DiscretionOffset_allocate);
  rb_define_method(SwigClassDiscretionOffset.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionOffset), -1);
  SwigClassDiscretionOffset.mark = 0;
  SwigClassDiscretionOffset.destroy = (void (*)(void *)) free_FIX_DiscretionOffset;
  SwigClassDiscretionOffset.trackObjects = 0;
  
  SwigClassContAmtType.klass = rb_define_class_under(mQuickfix, "ContAmtType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContAmtType, (void *) &SwigClassContAmtType);
  rb_define_alloc_func(SwigClassContAmtType.klass, _wrap_ContAmtType_allocate);
  rb_define_method(SwigClassContAmtType.klass, "initialize", VALUEFUNC(_wrap_new_ContAmtType), -1);
  SwigClassContAmtType.mark = 0;
  SwigClassContAmtType.destroy = (void (*)(void *)) free_FIX_ContAmtType;
  SwigClassContAmtType.trackObjects = 0;
  
  SwigClassMiscFeeCurr.klass = rb_define_class_under(mQuickfix, "MiscFeeCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeCurr, (void *) &SwigClassMiscFeeCurr);
  rb_define_alloc_func(SwigClassMiscFeeCurr.klass, _wrap_MiscFeeCurr_allocate);
  rb_define_method(SwigClassMiscFeeCurr.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeCurr), -1);
  SwigClassMiscFeeCurr.mark = 0;
  SwigClassMiscFeeCurr.destroy = (void (*)(void *)) free_FIX_MiscFeeCurr;
  SwigClassMiscFeeCurr.trackObjects = 0;
  
  SwigClassAttachmentPoint.klass = rb_define_class_under(mQuickfix, "AttachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AttachmentPoint, (void *) &SwigClassAttachmentPoint);
  rb_define_alloc_func(SwigClassAttachmentPoint.klass, _wrap_AttachmentPoint_allocate);
  rb_define_method(SwigClassAttachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_AttachmentPoint), -1);
  SwigClassAttachmentPoint.mark = 0;
  SwigClassAttachmentPoint.destroy = (void (*)(void *)) free_FIX_AttachmentPoint;
  SwigClassAttachmentPoint.trackObjects = 0;
  
  SwigClassOrderCategory.klass = rb_define_class_under(mQuickfix, "OrderCategory", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderCategory, (void *) &SwigClassOrderCategory);
  rb_define_alloc_func(SwigClassOrderCategory.klass, _wrap_OrderCategory_allocate);
  rb_define_method(SwigClassOrderCategory.klass, "initialize", VALUEFUNC(_wrap_new_OrderCategory), -1);
  SwigClassOrderCategory.mark = 0;
  SwigClassOrderCategory.destroy = (void (*)(void *)) free_FIX_OrderCategory;
  SwigClassOrderCategory.trackObjects = 0;
  
  SwigClassAdvTransType.klass = rb_define_class_under(mQuickfix, "AdvTransType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvTransType, (void *) &SwigClassAdvTransType);
  rb_define_alloc_func(SwigClassAdvTransType.klass, _wrap_AdvTransType_allocate);
  rb_define_method(SwigClassAdvTransType.klass, "initialize", VALUEFUNC(_wrap_new_AdvTransType), -1);
  SwigClassAdvTransType.mark = 0;
  SwigClassAdvTransType.destroy = (void (*)(void *)) free_FIX_AdvTransType;
  SwigClassAdvTransType.trackObjects = 0;
  
  SwigClassWtAverageLiquidity.klass = rb_define_class_under(mQuickfix, "WtAverageLiquidity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__WtAverageLiquidity, (void *) &SwigClassWtAverageLiquidity);
  rb_define_alloc_func(SwigClassWtAverageLiquidity.klass, _wrap_WtAverageLiquidity_allocate);
  rb_define_method(SwigClassWtAverageLiquidity.klass, "initialize", VALUEFUNC(_wrap_new_WtAverageLiquidity), -1);
  SwigClassWtAverageLiquidity.mark = 0;
  SwigClassWtAverageLiquidity.destroy = (void (*)(void *)) free_FIX_WtAverageLiquidity;
  SwigClassWtAverageLiquidity.trackObjects = 0;
  
  SwigClassQuoteSetValidUntilTime.klass = rb_define_class_under(mQuickfix, "QuoteSetValidUntilTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteSetValidUntilTime, (void *) &SwigClassQuoteSetValidUntilTime);
  rb_define_alloc_func(SwigClassQuoteSetValidUntilTime.klass, _wrap_QuoteSetValidUntilTime_allocate);
  rb_define_method(SwigClassQuoteSetValidUntilTime.klass, "initialize", VALUEFUNC(_wrap_new_QuoteSetValidUntilTime), -1);
  SwigClassQuoteSetValidUntilTime.mark = 0;
  SwigClassQuoteSetValidUntilTime.destroy = (void (*)(void *)) free_FIX_QuoteSetValidUntilTime;
  SwigClassQuoteSetValidUntilTime.trackObjects = 0;
  
  SwigClassNoNested4PartyIDs.klass = rb_define_class_under(mQuickfix, "NoNested4PartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested4PartyIDs, (void *) &SwigClassNoNested4PartyIDs);
  rb_define_alloc_func(SwigClassNoNested4PartyIDs.klass, _wrap_NoNested4PartyIDs_allocate);
  rb_define_method(SwigClassNoNested4PartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested4PartyIDs), -1);
  SwigClassNoNested4PartyIDs.mark = 0;
  SwigClassNoNested4PartyIDs.destroy = (void (*)(void *)) free_FIX_NoNested4PartyIDs;
  SwigClassNoNested4PartyIDs.trackObjects = 0;
  
  SwigClassLegPutOrCall.klass = rb_define_class_under(mQuickfix, "LegPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPutOrCall, (void *) &SwigClassLegPutOrCall);
  rb_define_alloc_func(SwigClassLegPutOrCall.klass, _wrap_LegPutOrCall_allocate);
  rb_define_method(SwigClassLegPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_LegPutOrCall), -1);
  SwigClassLegPutOrCall.mark = 0;
  SwigClassLegPutOrCall.destroy = (void (*)(void *)) free_FIX_LegPutOrCall;
  SwigClassLegPutOrCall.trackObjects = 0;
  
  SwigClassUserStatusText.klass = rb_define_class_under(mQuickfix, "UserStatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserStatusText, (void *) &SwigClassUserStatusText);
  rb_define_alloc_func(SwigClassUserStatusText.klass, _wrap_UserStatusText_allocate);
  rb_define_method(SwigClassUserStatusText.klass, "initialize", VALUEFUNC(_wrap_new_UserStatusText), -1);
  SwigClassUserStatusText.mark = 0;
  SwigClassUserStatusText.destroy = (void (*)(void *)) free_FIX_UserStatusText;
  SwigClassUserStatusText.trackObjects = 0;
  
  SwigClassNested2PartySubID.klass = rb_define_class_under(mQuickfix, "Nested2PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartySubID, (void *) &SwigClassNested2PartySubID);
  rb_define_alloc_func(SwigClassNested2PartySubID.klass, _wrap_Nested2PartySubID_allocate);
  rb_define_method(SwigClassNested2PartySubID.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartySubID), -1);
  SwigClassNested2PartySubID.mark = 0;
  SwigClassNested2PartySubID.destroy = (void (*)(void *)) free_FIX_Nested2PartySubID;
  SwigClassNested2PartySubID.trackObjects = 0;
  
  SwigClassEFPTrackingError.klass = rb_define_class_under(mQuickfix, "EFPTrackingError", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EFPTrackingError, (void *) &SwigClassEFPTrackingError);
  rb_define_alloc_func(SwigClassEFPTrackingError.klass, _wrap_EFPTrackingError_allocate);
  rb_define_method(SwigClassEFPTrackingError.klass, "initialize", VALUEFUNC(_wrap_new_EFPTrackingError), -1);
  SwigClassEFPTrackingError.mark = 0;
  SwigClassEFPTrackingError.destroy = (void (*)(void *)) free_FIX_EFPTrackingError;
  SwigClassEFPTrackingError.trackObjects = 0;
  
  SwigClassSideLiquidityInd.klass = rb_define_class_under(mQuickfix, "SideLiquidityInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideLiquidityInd, (void *) &SwigClassSideLiquidityInd);
  rb_define_alloc_func(SwigClassSideLiquidityInd.klass, _wrap_SideLiquidityInd_allocate);
  rb_define_method(SwigClassSideLiquidityInd.klass, "initialize", VALUEFUNC(_wrap_new_SideLiquidityInd), -1);
  SwigClassSideLiquidityInd.mark = 0;
  SwigClassSideLiquidityInd.destroy = (void (*)(void *)) free_FIX_SideLiquidityInd;
  SwigClassSideLiquidityInd.trackObjects = 0;
  
  SwigClassDerivativeMinPriceIncrement.klass = rb_define_class_under(mQuickfix, "DerivativeMinPriceIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMinPriceIncrement, (void *) &SwigClassDerivativeMinPriceIncrement);
  rb_define_alloc_func(SwigClassDerivativeMinPriceIncrement.klass, _wrap_DerivativeMinPriceIncrement_allocate);
  rb_define_method(SwigClassDerivativeMinPriceIncrement.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMinPriceIncrement), -1);
  SwigClassDerivativeMinPriceIncrement.mark = 0;
  SwigClassDerivativeMinPriceIncrement.destroy = (void (*)(void *)) free_FIX_DerivativeMinPriceIncrement;
  SwigClassDerivativeMinPriceIncrement.trackObjects = 0;
  
  SwigClassPublishTrdIndicator.klass = rb_define_class_under(mQuickfix, "PublishTrdIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PublishTrdIndicator, (void *) &SwigClassPublishTrdIndicator);
  rb_define_alloc_func(SwigClassPublishTrdIndicator.klass, _wrap_PublishTrdIndicator_allocate);
  rb_define_method(SwigClassPublishTrdIndicator.klass, "initialize", VALUEFUNC(_wrap_new_PublishTrdIndicator), -1);
  SwigClassPublishTrdIndicator.mark = 0;
  SwigClassPublishTrdIndicator.destroy = (void (*)(void *)) free_FIX_PublishTrdIndicator;
  SwigClassPublishTrdIndicator.trackObjects = 0;
  
  SwigClassInvestorCountryOfResidence.klass = rb_define_class_under(mQuickfix, "InvestorCountryOfResidence", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvestorCountryOfResidence, (void *) &SwigClassInvestorCountryOfResidence);
  rb_define_alloc_func(SwigClassInvestorCountryOfResidence.klass, _wrap_InvestorCountryOfResidence_allocate);
  rb_define_method(SwigClassInvestorCountryOfResidence.klass, "initialize", VALUEFUNC(_wrap_new_InvestorCountryOfResidence), -1);
  SwigClassInvestorCountryOfResidence.mark = 0;
  SwigClassInvestorCountryOfResidence.destroy = (void (*)(void *)) free_FIX_InvestorCountryOfResidence;
  SwigClassInvestorCountryOfResidence.trackObjects = 0;
  
  SwigClassSideReasonCd.klass = rb_define_class_under(mQuickfix, "SideReasonCd", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideReasonCd, (void *) &SwigClassSideReasonCd);
  rb_define_alloc_func(SwigClassSideReasonCd.klass, _wrap_SideReasonCd_allocate);
  rb_define_method(SwigClassSideReasonCd.klass, "initialize", VALUEFUNC(_wrap_new_SideReasonCd), -1);
  SwigClassSideReasonCd.mark = 0;
  SwigClassSideReasonCd.destroy = (void (*)(void *)) free_FIX_SideReasonCd;
  SwigClassSideReasonCd.trackObjects = 0;
  
  SwigClassMinPriceIncrement.klass = rb_define_class_under(mQuickfix, "MinPriceIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinPriceIncrement, (void *) &SwigClassMinPriceIncrement);
  rb_define_alloc_func(SwigClassMinPriceIncrement.klass, _wrap_MinPriceIncrement_allocate);
  rb_define_method(SwigClassMinPriceIncrement.klass, "initialize", VALUEFUNC(_wrap_new_MinPriceIncrement), -1);
  SwigClassMinPriceIncrement.mark = 0;
  SwigClassMinPriceIncrement.destroy = (void (*)(void *)) free_FIX_MinPriceIncrement;
  SwigClassMinPriceIncrement.trackObjects = 0;
  
  SwigClassSecuritySettlAgentContactName.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentContactName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentContactName, (void *) &SwigClassSecuritySettlAgentContactName);
  rb_define_alloc_func(SwigClassSecuritySettlAgentContactName.klass, _wrap_SecuritySettlAgentContactName_allocate);
  rb_define_method(SwigClassSecuritySettlAgentContactName.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentContactName), -1);
  SwigClassSecuritySettlAgentContactName.mark = 0;
  SwigClassSecuritySettlAgentContactName.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentContactName;
  SwigClassSecuritySettlAgentContactName.trackObjects = 0;
  
  SwigClassSecurityResponseType.klass = rb_define_class_under(mQuickfix, "SecurityResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityResponseType, (void *) &SwigClassSecurityResponseType);
  rb_define_alloc_func(SwigClassSecurityResponseType.klass, _wrap_SecurityResponseType_allocate);
  rb_define_method(SwigClassSecurityResponseType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityResponseType), -1);
  SwigClassSecurityResponseType.mark = 0;
  SwigClassSecurityResponseType.destroy = (void (*)(void *)) free_FIX_SecurityResponseType;
  SwigClassSecurityResponseType.trackObjects = 0;
  
  SwigClassLegBenchmarkCurvePoint.klass = rb_define_class_under(mQuickfix, "LegBenchmarkCurvePoint", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkCurvePoint, (void *) &SwigClassLegBenchmarkCurvePoint);
  rb_define_alloc_func(SwigClassLegBenchmarkCurvePoint.klass, _wrap_LegBenchmarkCurvePoint_allocate);
  rb_define_method(SwigClassLegBenchmarkCurvePoint.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkCurvePoint), -1);
  SwigClassLegBenchmarkCurvePoint.mark = 0;
  SwigClassLegBenchmarkCurvePoint.destroy = (void (*)(void *)) free_FIX_LegBenchmarkCurvePoint;
  SwigClassLegBenchmarkCurvePoint.trackObjects = 0;
  
  SwigClassClearingFirm.klass = rb_define_class_under(mQuickfix, "ClearingFirm", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingFirm, (void *) &SwigClassClearingFirm);
  rb_define_alloc_func(SwigClassClearingFirm.klass, _wrap_ClearingFirm_allocate);
  rb_define_method(SwigClassClearingFirm.klass, "initialize", VALUEFUNC(_wrap_new_ClearingFirm), -1);
  SwigClassClearingFirm.mark = 0;
  SwigClassClearingFirm.destroy = (void (*)(void *)) free_FIX_ClearingFirm;
  SwigClassClearingFirm.trackObjects = 0;
  
  SwigClassSessionStatus.klass = rb_define_class_under(mQuickfix, "SessionStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionStatus, (void *) &SwigClassSessionStatus);
  rb_define_alloc_func(SwigClassSessionStatus.klass, _wrap_SessionStatus_allocate);
  rb_define_method(SwigClassSessionStatus.klass, "initialize", VALUEFUNC(_wrap_new_SessionStatus), -1);
  SwigClassSessionStatus.mark = 0;
  SwigClassSessionStatus.destroy = (void (*)(void *)) free_FIX_SessionStatus;
  SwigClassSessionStatus.trackObjects = 0;
  
  SwigClassTriggerSecurityID.klass = rb_define_class_under(mQuickfix, "TriggerSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSecurityID, (void *) &SwigClassTriggerSecurityID);
  rb_define_alloc_func(SwigClassTriggerSecurityID.klass, _wrap_TriggerSecurityID_allocate);
  rb_define_method(SwigClassTriggerSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSecurityID), -1);
  SwigClassTriggerSecurityID.mark = 0;
  SwigClassTriggerSecurityID.destroy = (void (*)(void *)) free_FIX_TriggerSecurityID;
  SwigClassTriggerSecurityID.trackObjects = 0;
  
  SwigClassTotNoAllocs.klass = rb_define_class_under(mQuickfix, "TotNoAllocs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoAllocs, (void *) &SwigClassTotNoAllocs);
  rb_define_alloc_func(SwigClassTotNoAllocs.klass, _wrap_TotNoAllocs_allocate);
  rb_define_method(SwigClassTotNoAllocs.klass, "initialize", VALUEFUNC(_wrap_new_TotNoAllocs), -1);
  SwigClassTotNoAllocs.mark = 0;
  SwigClassTotNoAllocs.destroy = (void (*)(void *)) free_FIX_TotNoAllocs;
  SwigClassTotNoAllocs.trackObjects = 0;
  
  SwigClassNoAltMDSource.klass = rb_define_class_under(mQuickfix, "NoAltMDSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAltMDSource, (void *) &SwigClassNoAltMDSource);
  rb_define_alloc_func(SwigClassNoAltMDSource.klass, _wrap_NoAltMDSource_allocate);
  rb_define_method(SwigClassNoAltMDSource.klass, "initialize", VALUEFUNC(_wrap_new_NoAltMDSource), -1);
  SwigClassNoAltMDSource.mark = 0;
  SwigClassNoAltMDSource.destroy = (void (*)(void *)) free_FIX_NoAltMDSource;
  SwigClassNoAltMDSource.trackObjects = 0;
  
  SwigClassAllocAccountType.klass = rb_define_class_under(mQuickfix, "AllocAccountType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAccountType, (void *) &SwigClassAllocAccountType);
  rb_define_alloc_func(SwigClassAllocAccountType.klass, _wrap_AllocAccountType_allocate);
  rb_define_method(SwigClassAllocAccountType.klass, "initialize", VALUEFUNC(_wrap_new_AllocAccountType), -1);
  SwigClassAllocAccountType.mark = 0;
  SwigClassAllocAccountType.destroy = (void (*)(void *)) free_FIX_AllocAccountType;
  SwigClassAllocAccountType.trackObjects = 0;
  
  SwigClassLastPx.klass = rb_define_class_under(mQuickfix, "LastPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastPx, (void *) &SwigClassLastPx);
  rb_define_alloc_func(SwigClassLastPx.klass, _wrap_LastPx_allocate);
  rb_define_method(SwigClassLastPx.klass, "initialize", VALUEFUNC(_wrap_new_LastPx), -1);
  SwigClassLastPx.mark = 0;
  SwigClassLastPx.destroy = (void (*)(void *)) free_FIX_LastPx;
  SwigClassLastPx.trackObjects = 0;
  
  SwigClassAllocTransType.klass = rb_define_class_under(mQuickfix, "AllocTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocTransType, (void *) &SwigClassAllocTransType);
  rb_define_alloc_func(SwigClassAllocTransType.klass, _wrap_AllocTransType_allocate);
  rb_define_method(SwigClassAllocTransType.klass, "initialize", VALUEFUNC(_wrap_new_AllocTransType), -1);
  SwigClassAllocTransType.mark = 0;
  SwigClassAllocTransType.destroy = (void (*)(void *)) free_FIX_AllocTransType;
  SwigClassAllocTransType.trackObjects = 0;
  
  SwigClassTotNoQuoteEntries.klass = rb_define_class_under(mQuickfix, "TotNoQuoteEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoQuoteEntries, (void *) &SwigClassTotNoQuoteEntries);
  rb_define_alloc_func(SwigClassTotNoQuoteEntries.klass, _wrap_TotNoQuoteEntries_allocate);
  rb_define_method(SwigClassTotNoQuoteEntries.klass, "initialize", VALUEFUNC(_wrap_new_TotNoQuoteEntries), -1);
  SwigClassTotNoQuoteEntries.mark = 0;
  SwigClassTotNoQuoteEntries.destroy = (void (*)(void *)) free_FIX_TotNoQuoteEntries;
  SwigClassTotNoQuoteEntries.trackObjects = 0;
  
  SwigClassMinBidSize.klass = rb_define_class_under(mQuickfix, "MinBidSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinBidSize, (void *) &SwigClassMinBidSize);
  rb_define_alloc_func(SwigClassMinBidSize.klass, _wrap_MinBidSize_allocate);
  rb_define_method(SwigClassMinBidSize.klass, "initialize", VALUEFUNC(_wrap_new_MinBidSize), -1);
  SwigClassMinBidSize.mark = 0;
  SwigClassMinBidSize.destroy = (void (*)(void *)) free_FIX_MinBidSize;
  SwigClassMinBidSize.trackObjects = 0;
  
  SwigClassSettlBrkrCode.klass = rb_define_class_under(mQuickfix, "SettlBrkrCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlBrkrCode, (void *) &SwigClassSettlBrkrCode);
  rb_define_alloc_func(SwigClassSettlBrkrCode.klass, _wrap_SettlBrkrCode_allocate);
  rb_define_method(SwigClassSettlBrkrCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlBrkrCode), -1);
  SwigClassSettlBrkrCode.mark = 0;
  SwigClassSettlBrkrCode.destroy = (void (*)(void *)) free_FIX_SettlBrkrCode;
  SwigClassSettlBrkrCode.trackObjects = 0;
  
  SwigClassCardHolderName.klass = rb_define_class_under(mQuickfix, "CardHolderName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardHolderName, (void *) &SwigClassCardHolderName);
  rb_define_alloc_func(SwigClassCardHolderName.klass, _wrap_CardHolderName_allocate);
  rb_define_method(SwigClassCardHolderName.klass, "initialize", VALUEFUNC(_wrap_new_CardHolderName), -1);
  SwigClassCardHolderName.mark = 0;
  SwigClassCardHolderName.destroy = (void (*)(void *)) free_FIX_CardHolderName;
  SwigClassCardHolderName.trackObjects = 0;
  
  SwigClassExpirationQtyType.klass = rb_define_class_under(mQuickfix, "ExpirationQtyType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpirationQtyType, (void *) &SwigClassExpirationQtyType);
  rb_define_alloc_func(SwigClassExpirationQtyType.klass, _wrap_ExpirationQtyType_allocate);
  rb_define_method(SwigClassExpirationQtyType.klass, "initialize", VALUEFUNC(_wrap_new_ExpirationQtyType), -1);
  SwigClassExpirationQtyType.mark = 0;
  SwigClassExpirationQtyType.destroy = (void (*)(void *)) free_FIX_ExpirationQtyType;
  SwigClassExpirationQtyType.trackObjects = 0;
  
  SwigClassEncodedUnderlyingSecurityDescLen.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen, (void *) &SwigClassEncodedUnderlyingSecurityDescLen);
  rb_define_alloc_func(SwigClassEncodedUnderlyingSecurityDescLen.klass, _wrap_EncodedUnderlyingSecurityDescLen_allocate);
  rb_define_method(SwigClassEncodedUnderlyingSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingSecurityDescLen), -1);
  SwigClassEncodedUnderlyingSecurityDescLen.mark = 0;
  SwigClassEncodedUnderlyingSecurityDescLen.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingSecurityDescLen;
  SwigClassEncodedUnderlyingSecurityDescLen.trackObjects = 0;
  
  SwigClassQuoteReqID.klass = rb_define_class_under(mQuickfix, "QuoteReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteReqID, (void *) &SwigClassQuoteReqID);
  rb_define_alloc_func(SwigClassQuoteReqID.klass, _wrap_QuoteReqID_allocate);
  rb_define_method(SwigClassQuoteReqID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteReqID), -1);
  SwigClassQuoteReqID.mark = 0;
  SwigClassQuoteReqID.destroy = (void (*)(void *)) free_FIX_QuoteReqID;
  SwigClassQuoteReqID.trackObjects = 0;
  
  SwigClassPriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "PriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceUnitOfMeasure, (void *) &SwigClassPriceUnitOfMeasure);
  rb_define_alloc_func(SwigClassPriceUnitOfMeasure.klass, _wrap_PriceUnitOfMeasure_allocate);
  rb_define_method(SwigClassPriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_PriceUnitOfMeasure), -1);
  SwigClassPriceUnitOfMeasure.mark = 0;
  SwigClassPriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_PriceUnitOfMeasure;
  SwigClassPriceUnitOfMeasure.trackObjects = 0;
  
  SwigClassTZTransactTime.klass = rb_define_class_under(mQuickfix, "TZTransactTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TZTransactTime, (void *) &SwigClassTZTransactTime);
  rb_define_alloc_func(SwigClassTZTransactTime.klass, _wrap_TZTransactTime_allocate);
  rb_define_method(SwigClassTZTransactTime.klass, "initialize", VALUEFUNC(_wrap_new_TZTransactTime), -1);
  SwigClassTZTransactTime.mark = 0;
  SwigClassTZTransactTime.destroy = (void (*)(void *)) free_FIX_TZTransactTime;
  SwigClassTZTransactTime.trackObjects = 0;
  
  SwigClassAllocHandlInst.klass = rb_define_class_under(mQuickfix, "AllocHandlInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocHandlInst, (void *) &SwigClassAllocHandlInst);
  rb_define_alloc_func(SwigClassAllocHandlInst.klass, _wrap_AllocHandlInst_allocate);
  rb_define_method(SwigClassAllocHandlInst.klass, "initialize", VALUEFUNC(_wrap_new_AllocHandlInst), -1);
  SwigClassAllocHandlInst.mark = 0;
  SwigClassAllocHandlInst.destroy = (void (*)(void *)) free_FIX_AllocHandlInst;
  SwigClassAllocHandlInst.trackObjects = 0;
  
  SwigClassUnderlyingInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource, (void *) &SwigClassUnderlyingInstrumentPartyIDSource);
  rb_define_alloc_func(SwigClassUnderlyingInstrumentPartyIDSource.klass, _wrap_UnderlyingInstrumentPartyIDSource_allocate);
  rb_define_method(SwigClassUnderlyingInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartyIDSource), -1);
  SwigClassUnderlyingInstrumentPartyIDSource.mark = 0;
  SwigClassUnderlyingInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartyIDSource;
  SwigClassUnderlyingInstrumentPartyIDSource.trackObjects = 0;
  
  SwigClassCurrencyRatio.klass = rb_define_class_under(mQuickfix, "CurrencyRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CurrencyRatio, (void *) &SwigClassCurrencyRatio);
  rb_define_alloc_func(SwigClassCurrencyRatio.klass, _wrap_CurrencyRatio_allocate);
  rb_define_method(SwigClassCurrencyRatio.klass, "initialize", VALUEFUNC(_wrap_new_CurrencyRatio), -1);
  SwigClassCurrencyRatio.mark = 0;
  SwigClassCurrencyRatio.destroy = (void (*)(void *)) free_FIX_CurrencyRatio;
  SwigClassCurrencyRatio.trackObjects = 0;
  
  SwigClassRefreshQty.klass = rb_define_class_under(mQuickfix, "RefreshQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefreshQty, (void *) &SwigClassRefreshQty);
  rb_define_alloc_func(SwigClassRefreshQty.klass, _wrap_RefreshQty_allocate);
  rb_define_method(SwigClassRefreshQty.klass, "initialize", VALUEFUNC(_wrap_new_RefreshQty), -1);
  SwigClassRefreshQty.mark = 0;
  SwigClassRefreshQty.destroy = (void (*)(void *)) free_FIX_RefreshQty;
  SwigClassRefreshQty.trackObjects = 0;
  
  SwigClassTradeRequestStatus.klass = rb_define_class_under(mQuickfix, "TradeRequestStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestStatus, (void *) &SwigClassTradeRequestStatus);
  rb_define_alloc_func(SwigClassTradeRequestStatus.klass, _wrap_TradeRequestStatus_allocate);
  rb_define_method(SwigClassTradeRequestStatus.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestStatus), -1);
  SwigClassTradeRequestStatus.mark = 0;
  SwigClassTradeRequestStatus.destroy = (void (*)(void *)) free_FIX_TradeRequestStatus;
  SwigClassTradeRequestStatus.trackObjects = 0;
  
  SwigClassTrdRepIndicator.klass = rb_define_class_under(mQuickfix, "TrdRepIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRepIndicator, (void *) &SwigClassTrdRepIndicator);
  rb_define_alloc_func(SwigClassTrdRepIndicator.klass, _wrap_TrdRepIndicator_allocate);
  rb_define_method(SwigClassTrdRepIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TrdRepIndicator), -1);
  SwigClassTrdRepIndicator.mark = 0;
  SwigClassTrdRepIndicator.destroy = (void (*)(void *)) free_FIX_TrdRepIndicator;
  SwigClassTrdRepIndicator.trackObjects = 0;
  
  SwigClassMiscFeeAmt.klass = rb_define_class_under(mQuickfix, "MiscFeeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeAmt, (void *) &SwigClassMiscFeeAmt);
  rb_define_alloc_func(SwigClassMiscFeeAmt.klass, _wrap_MiscFeeAmt_allocate);
  rb_define_method(SwigClassMiscFeeAmt.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeAmt), -1);
  SwigClassMiscFeeAmt.mark = 0;
  SwigClassMiscFeeAmt.destroy = (void (*)(void *)) free_FIX_MiscFeeAmt;
  SwigClassMiscFeeAmt.trackObjects = 0;
  
  SwigClassTradSesOpenTime.klass = rb_define_class_under(mQuickfix, "TradSesOpenTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesOpenTime, (void *) &SwigClassTradSesOpenTime);
  rb_define_alloc_func(SwigClassTradSesOpenTime.klass, _wrap_TradSesOpenTime_allocate);
  rb_define_method(SwigClassTradSesOpenTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesOpenTime), -1);
  SwigClassTradSesOpenTime.mark = 0;
  SwigClassTradSesOpenTime.destroy = (void (*)(void *)) free_FIX_TradSesOpenTime;
  SwigClassTradSesOpenTime.trackObjects = 0;
  
  SwigClassPreallocMethod.klass = rb_define_class_under(mQuickfix, "PreallocMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PreallocMethod, (void *) &SwigClassPreallocMethod);
  rb_define_alloc_func(SwigClassPreallocMethod.klass, _wrap_PreallocMethod_allocate);
  rb_define_method(SwigClassPreallocMethod.klass, "initialize", VALUEFUNC(_wrap_new_PreallocMethod), -1);
  SwigClassPreallocMethod.mark = 0;
  SwigClassPreallocMethod.destroy = (void (*)(void *)) free_FIX_PreallocMethod;
  SwigClassPreallocMethod.trackObjects = 0;
  
  SwigClassTaxAdvantageType.klass = rb_define_class_under(mQuickfix, "TaxAdvantageType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TaxAdvantageType, (void *) &SwigClassTaxAdvantageType);
  rb_define_alloc_func(SwigClassTaxAdvantageType.klass, _wrap_TaxAdvantageType_allocate);
  rb_define_method(SwigClassTaxAdvantageType.klass, "initialize", VALUEFUNC(_wrap_new_TaxAdvantageType), -1);
  SwigClassTaxAdvantageType.mark = 0;
  SwigClassTaxAdvantageType.destroy = (void (*)(void *)) free_FIX_TaxAdvantageType;
  SwigClassTaxAdvantageType.trackObjects = 0;
  
  SwigClassMessageEncoding.klass = rb_define_class_under(mQuickfix, "MessageEncoding", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageEncoding, (void *) &SwigClassMessageEncoding);
  rb_define_alloc_func(SwigClassMessageEncoding.klass, _wrap_MessageEncoding_allocate);
  rb_define_method(SwigClassMessageEncoding.klass, "initialize", VALUEFUNC(_wrap_new_MessageEncoding), -1);
  SwigClassMessageEncoding.mark = 0;
  SwigClassMessageEncoding.destroy = (void (*)(void *)) free_FIX_MessageEncoding;
  SwigClassMessageEncoding.trackObjects = 0;
  
  SwigClassNoPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartySubIDs, (void *) &SwigClassNoPartySubIDs);
  rb_define_alloc_func(SwigClassNoPartySubIDs.klass, _wrap_NoPartySubIDs_allocate);
  rb_define_method(SwigClassNoPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoPartySubIDs), -1);
  SwigClassNoPartySubIDs.mark = 0;
  SwigClassNoPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoPartySubIDs;
  SwigClassNoPartySubIDs.trackObjects = 0;
  
  SwigClassSettlInstReqID.klass = rb_define_class_under(mQuickfix, "SettlInstReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstReqID, (void *) &SwigClassSettlInstReqID);
  rb_define_alloc_func(SwigClassSettlInstReqID.klass, _wrap_SettlInstReqID_allocate);
  rb_define_method(SwigClassSettlInstReqID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstReqID), -1);
  SwigClassSettlInstReqID.mark = 0;
  SwigClassSettlInstReqID.destroy = (void (*)(void *)) free_FIX_SettlInstReqID;
  SwigClassSettlInstReqID.trackObjects = 0;
  
  SwigClassLegRepoCollateralSecurityType.klass = rb_define_class_under(mQuickfix, "LegRepoCollateralSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRepoCollateralSecurityType, (void *) &SwigClassLegRepoCollateralSecurityType);
  rb_define_alloc_func(SwigClassLegRepoCollateralSecurityType.klass, _wrap_LegRepoCollateralSecurityType_allocate);
  rb_define_method(SwigClassLegRepoCollateralSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_LegRepoCollateralSecurityType), -1);
  SwigClassLegRepoCollateralSecurityType.mark = 0;
  SwigClassLegRepoCollateralSecurityType.destroy = (void (*)(void *)) free_FIX_LegRepoCollateralSecurityType;
  SwigClassLegRepoCollateralSecurityType.trackObjects = 0;
  
  SwigClassAffectedSecondaryOrderID.klass = rb_define_class_under(mQuickfix, "AffectedSecondaryOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AffectedSecondaryOrderID, (void *) &SwigClassAffectedSecondaryOrderID);
  rb_define_alloc_func(SwigClassAffectedSecondaryOrderID.klass, _wrap_AffectedSecondaryOrderID_allocate);
  rb_define_method(SwigClassAffectedSecondaryOrderID.klass, "initialize", VALUEFUNC(_wrap_new_AffectedSecondaryOrderID), -1);
  SwigClassAffectedSecondaryOrderID.mark = 0;
  SwigClassAffectedSecondaryOrderID.destroy = (void (*)(void *)) free_FIX_AffectedSecondaryOrderID;
  SwigClassAffectedSecondaryOrderID.trackObjects = 0;
  
  SwigClassDerivativeMaturityTime.klass = rb_define_class_under(mQuickfix, "DerivativeMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMaturityTime, (void *) &SwigClassDerivativeMaturityTime);
  rb_define_alloc_func(SwigClassDerivativeMaturityTime.klass, _wrap_DerivativeMaturityTime_allocate);
  rb_define_method(SwigClassDerivativeMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMaturityTime), -1);
  SwigClassDerivativeMaturityTime.mark = 0;
  SwigClassDerivativeMaturityTime.destroy = (void (*)(void *)) free_FIX_DerivativeMaturityTime;
  SwigClassDerivativeMaturityTime.trackObjects = 0;
  
  SwigClassExpireTime.klass = rb_define_class_under(mQuickfix, "ExpireTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpireTime, (void *) &SwigClassExpireTime);
  rb_define_alloc_func(SwigClassExpireTime.klass, _wrap_ExpireTime_allocate);
  rb_define_method(SwigClassExpireTime.klass, "initialize", VALUEFUNC(_wrap_new_ExpireTime), -1);
  SwigClassExpireTime.mark = 0;
  SwigClassExpireTime.destroy = (void (*)(void *)) free_FIX_ExpireTime;
  SwigClassExpireTime.trackObjects = 0;
  
  SwigClassUnderlyingFactor.klass = rb_define_class_under(mQuickfix, "UnderlyingFactor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFactor, (void *) &SwigClassUnderlyingFactor);
  rb_define_alloc_func(SwigClassUnderlyingFactor.klass, _wrap_UnderlyingFactor_allocate);
  rb_define_method(SwigClassUnderlyingFactor.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFactor), -1);
  SwigClassUnderlyingFactor.mark = 0;
  SwigClassUnderlyingFactor.destroy = (void (*)(void *)) free_FIX_UnderlyingFactor;
  SwigClassUnderlyingFactor.trackObjects = 0;
  
  SwigClassOrigOrdModTime.klass = rb_define_class_under(mQuickfix, "OrigOrdModTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigOrdModTime, (void *) &SwigClassOrigOrdModTime);
  rb_define_alloc_func(SwigClassOrigOrdModTime.klass, _wrap_OrigOrdModTime_allocate);
  rb_define_method(SwigClassOrigOrdModTime.klass, "initialize", VALUEFUNC(_wrap_new_OrigOrdModTime), -1);
  SwigClassOrigOrdModTime.mark = 0;
  SwigClassOrigOrdModTime.destroy = (void (*)(void *)) free_FIX_OrigOrdModTime;
  SwigClassOrigOrdModTime.trackObjects = 0;
  
  SwigClassNoTrdRepIndicators.klass = rb_define_class_under(mQuickfix, "NoTrdRepIndicators", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTrdRepIndicators, (void *) &SwigClassNoTrdRepIndicators);
  rb_define_alloc_func(SwigClassNoTrdRepIndicators.klass, _wrap_NoTrdRepIndicators_allocate);
  rb_define_method(SwigClassNoTrdRepIndicators.klass, "initialize", VALUEFUNC(_wrap_new_NoTrdRepIndicators), -1);
  SwigClassNoTrdRepIndicators.mark = 0;
  SwigClassNoTrdRepIndicators.destroy = (void (*)(void *)) free_FIX_NoTrdRepIndicators;
  SwigClassNoTrdRepIndicators.trackObjects = 0;
  
  SwigClassDerivativeMaturityDate.klass = rb_define_class_under(mQuickfix, "DerivativeMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMaturityDate, (void *) &SwigClassDerivativeMaturityDate);
  rb_define_alloc_func(SwigClassDerivativeMaturityDate.klass, _wrap_DerivativeMaturityDate_allocate);
  rb_define_method(SwigClassDerivativeMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMaturityDate), -1);
  SwigClassDerivativeMaturityDate.mark = 0;
  SwigClassDerivativeMaturityDate.destroy = (void (*)(void *)) free_FIX_DerivativeMaturityDate;
  SwigClassDerivativeMaturityDate.trackObjects = 0;
  
  SwigClassDerivativeCFICode.klass = rb_define_class_under(mQuickfix, "DerivativeCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeCFICode, (void *) &SwigClassDerivativeCFICode);
  rb_define_alloc_func(SwigClassDerivativeCFICode.klass, _wrap_DerivativeCFICode_allocate);
  rb_define_method(SwigClassDerivativeCFICode.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeCFICode), -1);
  SwigClassDerivativeCFICode.mark = 0;
  SwigClassDerivativeCFICode.destroy = (void (*)(void *)) free_FIX_DerivativeCFICode;
  SwigClassDerivativeCFICode.trackObjects = 0;
  
  SwigClassNested2PartySubIDType.klass = rb_define_class_under(mQuickfix, "Nested2PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartySubIDType, (void *) &SwigClassNested2PartySubIDType);
  rb_define_alloc_func(SwigClassNested2PartySubIDType.klass, _wrap_Nested2PartySubIDType_allocate);
  rb_define_method(SwigClassNested2PartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartySubIDType), -1);
  SwigClassNested2PartySubIDType.mark = 0;
  SwigClassNested2PartySubIDType.destroy = (void (*)(void *)) free_FIX_Nested2PartySubIDType;
  SwigClassNested2PartySubIDType.trackObjects = 0;
  
  SwigClassLegIOIQty.klass = rb_define_class_under(mQuickfix, "LegIOIQty", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIOIQty, (void *) &SwigClassLegIOIQty);
  rb_define_alloc_func(SwigClassLegIOIQty.klass, _wrap_LegIOIQty_allocate);
  rb_define_method(SwigClassLegIOIQty.klass, "initialize", VALUEFUNC(_wrap_new_LegIOIQty), -1);
  SwigClassLegIOIQty.mark = 0;
  SwigClassLegIOIQty.destroy = (void (*)(void *)) free_FIX_LegIOIQty;
  SwigClassLegIOIQty.trackObjects = 0;
  
  SwigClassExpireDate.klass = rb_define_class_under(mQuickfix, "ExpireDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpireDate, (void *) &SwigClassExpireDate);
  rb_define_alloc_func(SwigClassExpireDate.klass, _wrap_ExpireDate_allocate);
  rb_define_method(SwigClassExpireDate.klass, "initialize", VALUEFUNC(_wrap_new_ExpireDate), -1);
  SwigClassExpireDate.mark = 0;
  SwigClassExpireDate.destroy = (void (*)(void *)) free_FIX_ExpireDate;
  SwigClassExpireDate.trackObjects = 0;
  
  SwigClassNoMatchRules.klass = rb_define_class_under(mQuickfix, "NoMatchRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMatchRules, (void *) &SwigClassNoMatchRules);
  rb_define_alloc_func(SwigClassNoMatchRules.klass, _wrap_NoMatchRules_allocate);
  rb_define_method(SwigClassNoMatchRules.klass, "initialize", VALUEFUNC(_wrap_new_NoMatchRules), -1);
  SwigClassNoMatchRules.mark = 0;
  SwigClassNoMatchRules.destroy = (void (*)(void *)) free_FIX_NoMatchRules;
  SwigClassNoMatchRules.trackObjects = 0;
  
  SwigClassApplEndSeqNum.klass = rb_define_class_under(mQuickfix, "ApplEndSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplEndSeqNum, (void *) &SwigClassApplEndSeqNum);
  rb_define_alloc_func(SwigClassApplEndSeqNum.klass, _wrap_ApplEndSeqNum_allocate);
  rb_define_method(SwigClassApplEndSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplEndSeqNum), -1);
  SwigClassApplEndSeqNum.mark = 0;
  SwigClassApplEndSeqNum.destroy = (void (*)(void *)) free_FIX_ApplEndSeqNum;
  SwigClassApplEndSeqNum.trackObjects = 0;
  
  SwigClassEventPx.klass = rb_define_class_under(mQuickfix, "EventPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventPx, (void *) &SwigClassEventPx);
  rb_define_alloc_func(SwigClassEventPx.klass, _wrap_EventPx_allocate);
  rb_define_method(SwigClassEventPx.klass, "initialize", VALUEFUNC(_wrap_new_EventPx), -1);
  SwigClassEventPx.mark = 0;
  SwigClassEventPx.destroy = (void (*)(void *)) free_FIX_EventPx;
  SwigClassEventPx.trackObjects = 0;
  
  SwigClassAsgnRptID.klass = rb_define_class_under(mQuickfix, "AsgnRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AsgnRptID, (void *) &SwigClassAsgnRptID);
  rb_define_alloc_func(SwigClassAsgnRptID.klass, _wrap_AsgnRptID_allocate);
  rb_define_method(SwigClassAsgnRptID.klass, "initialize", VALUEFUNC(_wrap_new_AsgnRptID), -1);
  SwigClassAsgnRptID.mark = 0;
  SwigClassAsgnRptID.destroy = (void (*)(void *)) free_FIX_AsgnRptID;
  SwigClassAsgnRptID.trackObjects = 0;
  
  SwigClassTimeInForce.klass = rb_define_class_under(mQuickfix, "TimeInForce", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeInForce, (void *) &SwigClassTimeInForce);
  rb_define_alloc_func(SwigClassTimeInForce.klass, _wrap_TimeInForce_allocate);
  rb_define_method(SwigClassTimeInForce.klass, "initialize", VALUEFUNC(_wrap_new_TimeInForce), -1);
  SwigClassTimeInForce.mark = 0;
  SwigClassTimeInForce.destroy = (void (*)(void *)) free_FIX_TimeInForce;
  SwigClassTimeInForce.trackObjects = 0;
  
  SwigClassLowPx.klass = rb_define_class_under(mQuickfix, "LowPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LowPx, (void *) &SwigClassLowPx);
  rb_define_alloc_func(SwigClassLowPx.klass, _wrap_LowPx_allocate);
  rb_define_method(SwigClassLowPx.klass, "initialize", VALUEFUNC(_wrap_new_LowPx), -1);
  SwigClassLowPx.mark = 0;
  SwigClassLowPx.destroy = (void (*)(void *)) free_FIX_LowPx;
  SwigClassLowPx.trackObjects = 0;
  
  SwigClassIOIQualifier.klass = rb_define_class_under(mQuickfix, "IOIQualifier", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIQualifier, (void *) &SwigClassIOIQualifier);
  rb_define_alloc_func(SwigClassIOIQualifier.klass, _wrap_IOIQualifier_allocate);
  rb_define_method(SwigClassIOIQualifier.klass, "initialize", VALUEFUNC(_wrap_new_IOIQualifier), -1);
  SwigClassIOIQualifier.mark = 0;
  SwigClassIOIQualifier.destroy = (void (*)(void *)) free_FIX_IOIQualifier;
  SwigClassIOIQualifier.trackObjects = 0;
  
  SwigClassWaveNo.klass = rb_define_class_under(mQuickfix, "WaveNo", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__WaveNo, (void *) &SwigClassWaveNo);
  rb_define_alloc_func(SwigClassWaveNo.klass, _wrap_WaveNo_allocate);
  rb_define_method(SwigClassWaveNo.klass, "initialize", VALUEFUNC(_wrap_new_WaveNo), -1);
  SwigClassWaveNo.mark = 0;
  SwigClassWaveNo.destroy = (void (*)(void *)) free_FIX_WaveNo;
  SwigClassWaveNo.trackObjects = 0;
  
  SwigClassStrikePriceBoundaryMethod.klass = rb_define_class_under(mQuickfix, "StrikePriceBoundaryMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePriceBoundaryMethod, (void *) &SwigClassStrikePriceBoundaryMethod);
  rb_define_alloc_func(SwigClassStrikePriceBoundaryMethod.klass, _wrap_StrikePriceBoundaryMethod_allocate);
  rb_define_method(SwigClassStrikePriceBoundaryMethod.klass, "initialize", VALUEFUNC(_wrap_new_StrikePriceBoundaryMethod), -1);
  SwigClassStrikePriceBoundaryMethod.mark = 0;
  SwigClassStrikePriceBoundaryMethod.destroy = (void (*)(void *)) free_FIX_StrikePriceBoundaryMethod;
  SwigClassStrikePriceBoundaryMethod.trackObjects = 0;
  
  SwigClassDerivativeIssueDate.klass = rb_define_class_under(mQuickfix, "DerivativeIssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeIssueDate, (void *) &SwigClassDerivativeIssueDate);
  rb_define_alloc_func(SwigClassDerivativeIssueDate.klass, _wrap_DerivativeIssueDate_allocate);
  rb_define_method(SwigClassDerivativeIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeIssueDate), -1);
  SwigClassDerivativeIssueDate.mark = 0;
  SwigClassDerivativeIssueDate.destroy = (void (*)(void *)) free_FIX_DerivativeIssueDate;
  SwigClassDerivativeIssueDate.trackObjects = 0;
  
  SwigClassMiscFeeType.klass = rb_define_class_under(mQuickfix, "MiscFeeType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeType, (void *) &SwigClassMiscFeeType);
  rb_define_alloc_func(SwigClassMiscFeeType.klass, _wrap_MiscFeeType_allocate);
  rb_define_method(SwigClassMiscFeeType.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeType), -1);
  SwigClassMiscFeeType.mark = 0;
  SwigClassMiscFeeType.destroy = (void (*)(void *)) free_FIX_MiscFeeType;
  SwigClassMiscFeeType.trackObjects = 0;
  
  SwigClassQuoteID.klass = rb_define_class_under(mQuickfix, "QuoteID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteID, (void *) &SwigClassQuoteID);
  rb_define_alloc_func(SwigClassQuoteID.klass, _wrap_QuoteID_allocate);
  rb_define_method(SwigClassQuoteID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteID), -1);
  SwigClassQuoteID.mark = 0;
  SwigClassQuoteID.destroy = (void (*)(void *)) free_FIX_QuoteID;
  SwigClassQuoteID.trackObjects = 0;
  
  SwigClassDerivativeInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource, (void *) &SwigClassDerivativeInstrumentPartyIDSource);
  rb_define_alloc_func(SwigClassDerivativeInstrumentPartyIDSource.klass, _wrap_DerivativeInstrumentPartyIDSource_allocate);
  rb_define_method(SwigClassDerivativeInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartyIDSource), -1);
  SwigClassDerivativeInstrumentPartyIDSource.mark = 0;
  SwigClassDerivativeInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartyIDSource;
  SwigClassDerivativeInstrumentPartyIDSource.trackObjects = 0;
  
  SwigClassSettlObligID.klass = rb_define_class_under(mQuickfix, "SettlObligID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligID, (void *) &SwigClassSettlObligID);
  rb_define_alloc_func(SwigClassSettlObligID.klass, _wrap_SettlObligID_allocate);
  rb_define_method(SwigClassSettlObligID.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligID), -1);
  SwigClassSettlObligID.mark = 0;
  SwigClassSettlObligID.destroy = (void (*)(void *)) free_FIX_SettlObligID;
  SwigClassSettlObligID.trackObjects = 0;
  
  SwigClassInstrAttribValue.klass = rb_define_class_under(mQuickfix, "InstrAttribValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrAttribValue, (void *) &SwigClassInstrAttribValue);
  rb_define_alloc_func(SwigClassInstrAttribValue.klass, _wrap_InstrAttribValue_allocate);
  rb_define_method(SwigClassInstrAttribValue.klass, "initialize", VALUEFUNC(_wrap_new_InstrAttribValue), -1);
  SwigClassInstrAttribValue.mark = 0;
  SwigClassInstrAttribValue.destroy = (void (*)(void *)) free_FIX_InstrAttribValue;
  SwigClassInstrAttribValue.trackObjects = 0;
  
  SwigClassLiquidityValue.klass = rb_define_class_under(mQuickfix, "LiquidityValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityValue, (void *) &SwigClassLiquidityValue);
  rb_define_alloc_func(SwigClassLiquidityValue.klass, _wrap_LiquidityValue_allocate);
  rb_define_method(SwigClassLiquidityValue.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityValue), -1);
  SwigClassLiquidityValue.mark = 0;
  SwigClassLiquidityValue.destroy = (void (*)(void *)) free_FIX_LiquidityValue;
  SwigClassLiquidityValue.trackObjects = 0;
  
  SwigClassSecurityIDSource.klass = rb_define_class_under(mQuickfix, "SecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityIDSource, (void *) &SwigClassSecurityIDSource);
  rb_define_alloc_func(SwigClassSecurityIDSource.klass, _wrap_SecurityIDSource_allocate);
  rb_define_method(SwigClassSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_SecurityIDSource), -1);
  SwigClassSecurityIDSource.mark = 0;
  SwigClassSecurityIDSource.destroy = (void (*)(void *)) free_FIX_SecurityIDSource;
  SwigClassSecurityIDSource.trackObjects = 0;
  
  SwigClassNewsRefType.klass = rb_define_class_under(mQuickfix, "NewsRefType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsRefType, (void *) &SwigClassNewsRefType);
  rb_define_alloc_func(SwigClassNewsRefType.klass, _wrap_NewsRefType_allocate);
  rb_define_method(SwigClassNewsRefType.klass, "initialize", VALUEFUNC(_wrap_new_NewsRefType), -1);
  SwigClassNewsRefType.mark = 0;
  SwigClassNewsRefType.destroy = (void (*)(void *)) free_FIX_NewsRefType;
  SwigClassNewsRefType.trackObjects = 0;
  
  SwigClassNoOfLegUnderlyings.klass = rb_define_class_under(mQuickfix, "NoOfLegUnderlyings", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOfLegUnderlyings, (void *) &SwigClassNoOfLegUnderlyings);
  rb_define_alloc_func(SwigClassNoOfLegUnderlyings.klass, _wrap_NoOfLegUnderlyings_allocate);
  rb_define_method(SwigClassNoOfLegUnderlyings.klass, "initialize", VALUEFUNC(_wrap_new_NoOfLegUnderlyings), -1);
  SwigClassNoOfLegUnderlyings.mark = 0;
  SwigClassNoOfLegUnderlyings.destroy = (void (*)(void *)) free_FIX_NoOfLegUnderlyings;
  SwigClassNoOfLegUnderlyings.trackObjects = 0;
  
  SwigClassDerivativeEncodedSecurityDesc.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc, (void *) &SwigClassDerivativeEncodedSecurityDesc);
  rb_define_alloc_func(SwigClassDerivativeEncodedSecurityDesc.klass, _wrap_DerivativeEncodedSecurityDesc_allocate);
  rb_define_method(SwigClassDerivativeEncodedSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedSecurityDesc), -1);
  SwigClassDerivativeEncodedSecurityDesc.mark = 0;
  SwigClassDerivativeEncodedSecurityDesc.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedSecurityDesc;
  SwigClassDerivativeEncodedSecurityDesc.trackObjects = 0;
  
  SwigClassTriggerOrderType.klass = rb_define_class_under(mQuickfix, "TriggerOrderType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerOrderType, (void *) &SwigClassTriggerOrderType);
  rb_define_alloc_func(SwigClassTriggerOrderType.klass, _wrap_TriggerOrderType_allocate);
  rb_define_method(SwigClassTriggerOrderType.klass, "initialize", VALUEFUNC(_wrap_new_TriggerOrderType), -1);
  SwigClassTriggerOrderType.mark = 0;
  SwigClassTriggerOrderType.destroy = (void (*)(void *)) free_FIX_TriggerOrderType;
  SwigClassTriggerOrderType.trackObjects = 0;
  
  SwigClassUnderlyingDirtyPrice.klass = rb_define_class_under(mQuickfix, "UnderlyingDirtyPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingDirtyPrice, (void *) &SwigClassUnderlyingDirtyPrice);
  rb_define_alloc_func(SwigClassUnderlyingDirtyPrice.klass, _wrap_UnderlyingDirtyPrice_allocate);
  rb_define_method(SwigClassUnderlyingDirtyPrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingDirtyPrice), -1);
  SwigClassUnderlyingDirtyPrice.mark = 0;
  SwigClassUnderlyingDirtyPrice.destroy = (void (*)(void *)) free_FIX_UnderlyingDirtyPrice;
  SwigClassUnderlyingDirtyPrice.trackObjects = 0;
  
  SwigClassCrossType.klass = rb_define_class_under(mQuickfix, "CrossType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossType, (void *) &SwigClassCrossType);
  rb_define_alloc_func(SwigClassCrossType.klass, _wrap_CrossType_allocate);
  rb_define_method(SwigClassCrossType.klass, "initialize", VALUEFUNC(_wrap_new_CrossType), -1);
  SwigClassCrossType.mark = 0;
  SwigClassCrossType.destroy = (void (*)(void *)) free_FIX_CrossType;
  SwigClassCrossType.trackObjects = 0;
  
  SwigClassRepoCollateralSecurityType.klass = rb_define_class_under(mQuickfix, "RepoCollateralSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepoCollateralSecurityType, (void *) &SwigClassRepoCollateralSecurityType);
  rb_define_alloc_func(SwigClassRepoCollateralSecurityType.klass, _wrap_RepoCollateralSecurityType_allocate);
  rb_define_method(SwigClassRepoCollateralSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_RepoCollateralSecurityType), -1);
  SwigClassRepoCollateralSecurityType.mark = 0;
  SwigClassRepoCollateralSecurityType.destroy = (void (*)(void *)) free_FIX_RepoCollateralSecurityType;
  SwigClassRepoCollateralSecurityType.trackObjects = 0;
  
  SwigClassPassword.klass = rb_define_class_under(mQuickfix, "Password", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Password, (void *) &SwigClassPassword);
  rb_define_alloc_func(SwigClassPassword.klass, _wrap_Password_allocate);
  rb_define_method(SwigClassPassword.klass, "initialize", VALUEFUNC(_wrap_new_Password), -1);
  SwigClassPassword.mark = 0;
  SwigClassPassword.destroy = (void (*)(void *)) free_FIX_Password;
  SwigClassPassword.trackObjects = 0;
  
  SwigClassOpenCloseSettleFlag.klass = rb_define_class_under(mQuickfix, "OpenCloseSettleFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenCloseSettleFlag, (void *) &SwigClassOpenCloseSettleFlag);
  rb_define_alloc_func(SwigClassOpenCloseSettleFlag.klass, _wrap_OpenCloseSettleFlag_allocate);
  rb_define_method(SwigClassOpenCloseSettleFlag.klass, "initialize", VALUEFUNC(_wrap_new_OpenCloseSettleFlag), -1);
  SwigClassOpenCloseSettleFlag.mark = 0;
  SwigClassOpenCloseSettleFlag.destroy = (void (*)(void *)) free_FIX_OpenCloseSettleFlag;
  SwigClassOpenCloseSettleFlag.trackObjects = 0;
  
  SwigClassSubject.klass = rb_define_class_under(mQuickfix, "Subject", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Subject, (void *) &SwigClassSubject);
  rb_define_alloc_func(SwigClassSubject.klass, _wrap_Subject_allocate);
  rb_define_method(SwigClassSubject.klass, "initialize", VALUEFUNC(_wrap_new_Subject), -1);
  SwigClassSubject.mark = 0;
  SwigClassSubject.destroy = (void (*)(void *)) free_FIX_Subject;
  SwigClassSubject.trackObjects = 0;
  
  SwigClassRefApplReqID.klass = rb_define_class_under(mQuickfix, "RefApplReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplReqID, (void *) &SwigClassRefApplReqID);
  rb_define_alloc_func(SwigClassRefApplReqID.klass, _wrap_RefApplReqID_allocate);
  rb_define_method(SwigClassRefApplReqID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplReqID), -1);
  SwigClassRefApplReqID.mark = 0;
  SwigClassRefApplReqID.destroy = (void (*)(void *)) free_FIX_RefApplReqID;
  SwigClassRefApplReqID.trackObjects = 0;
  
  SwigClassUnderlyingEndValue.klass = rb_define_class_under(mQuickfix, "UnderlyingEndValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingEndValue, (void *) &SwigClassUnderlyingEndValue);
  rb_define_alloc_func(SwigClassUnderlyingEndValue.klass, _wrap_UnderlyingEndValue_allocate);
  rb_define_method(SwigClassUnderlyingEndValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingEndValue), -1);
  SwigClassUnderlyingEndValue.mark = 0;
  SwigClassUnderlyingEndValue.destroy = (void (*)(void *)) free_FIX_UnderlyingEndValue;
  SwigClassUnderlyingEndValue.trackObjects = 0;
  
  SwigClassNewSeqNo.klass = rb_define_class_under(mQuickfix, "NewSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewSeqNo, (void *) &SwigClassNewSeqNo);
  rb_define_alloc_func(SwigClassNewSeqNo.klass, _wrap_NewSeqNo_allocate);
  rb_define_method(SwigClassNewSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_NewSeqNo), -1);
  SwigClassNewSeqNo.mark = 0;
  SwigClassNewSeqNo.destroy = (void (*)(void *)) free_FIX_NewSeqNo;
  SwigClassNewSeqNo.trackObjects = 0;
  
  SwigClassOrigTradeHandlingInstr.klass = rb_define_class_under(mQuickfix, "OrigTradeHandlingInstr", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTradeHandlingInstr, (void *) &SwigClassOrigTradeHandlingInstr);
  rb_define_alloc_func(SwigClassOrigTradeHandlingInstr.klass, _wrap_OrigTradeHandlingInstr_allocate);
  rb_define_method(SwigClassOrigTradeHandlingInstr.klass, "initialize", VALUEFUNC(_wrap_new_OrigTradeHandlingInstr), -1);
  SwigClassOrigTradeHandlingInstr.mark = 0;
  SwigClassOrigTradeHandlingInstr.destroy = (void (*)(void *)) free_FIX_OrigTradeHandlingInstr;
  SwigClassOrigTradeHandlingInstr.trackObjects = 0;
  
  SwigClassDisplayHighQty.klass = rb_define_class_under(mQuickfix, "DisplayHighQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayHighQty, (void *) &SwigClassDisplayHighQty);
  rb_define_alloc_func(SwigClassDisplayHighQty.klass, _wrap_DisplayHighQty_allocate);
  rb_define_method(SwigClassDisplayHighQty.klass, "initialize", VALUEFUNC(_wrap_new_DisplayHighQty), -1);
  SwigClassDisplayHighQty.mark = 0;
  SwigClassDisplayHighQty.destroy = (void (*)(void *)) free_FIX_DisplayHighQty;
  SwigClassDisplayHighQty.trackObjects = 0;
  
  SwigClassMDBookType.klass = rb_define_class_under(mQuickfix, "MDBookType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDBookType, (void *) &SwigClassMDBookType);
  rb_define_alloc_func(SwigClassMDBookType.klass, _wrap_MDBookType_allocate);
  rb_define_method(SwigClassMDBookType.klass, "initialize", VALUEFUNC(_wrap_new_MDBookType), -1);
  SwigClassMDBookType.mark = 0;
  SwigClassMDBookType.destroy = (void (*)(void *)) free_FIX_MDBookType;
  SwigClassMDBookType.trackObjects = 0;
  
  SwigClassMarginExcess.klass = rb_define_class_under(mQuickfix, "MarginExcess", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarginExcess, (void *) &SwigClassMarginExcess);
  rb_define_alloc_func(SwigClassMarginExcess.klass, _wrap_MarginExcess_allocate);
  rb_define_method(SwigClassMarginExcess.klass, "initialize", VALUEFUNC(_wrap_new_MarginExcess), -1);
  SwigClassMarginExcess.mark = 0;
  SwigClassMarginExcess.destroy = (void (*)(void *)) free_FIX_MarginExcess;
  SwigClassMarginExcess.trackObjects = 0;
  
  SwigClassBasisPxType.klass = rb_define_class_under(mQuickfix, "BasisPxType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BasisPxType, (void *) &SwigClassBasisPxType);
  rb_define_alloc_func(SwigClassBasisPxType.klass, _wrap_BasisPxType_allocate);
  rb_define_method(SwigClassBasisPxType.klass, "initialize", VALUEFUNC(_wrap_new_BasisPxType), -1);
  SwigClassBasisPxType.mark = 0;
  SwigClassBasisPxType.destroy = (void (*)(void *)) free_FIX_BasisPxType;
  SwigClassBasisPxType.trackObjects = 0;
  
  SwigClassDlvyInst.klass = rb_define_class_under(mQuickfix, "DlvyInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DlvyInst, (void *) &SwigClassDlvyInst);
  rb_define_alloc_func(SwigClassDlvyInst.klass, _wrap_DlvyInst_allocate);
  rb_define_method(SwigClassDlvyInst.klass, "initialize", VALUEFUNC(_wrap_new_DlvyInst), -1);
  SwigClassDlvyInst.mark = 0;
  SwigClassDlvyInst.destroy = (void (*)(void *)) free_FIX_DlvyInst;
  SwigClassDlvyInst.trackObjects = 0;
  
  SwigClassComplianceID.klass = rb_define_class_under(mQuickfix, "ComplianceID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplianceID, (void *) &SwigClassComplianceID);
  rb_define_alloc_func(SwigClassComplianceID.klass, _wrap_ComplianceID_allocate);
  rb_define_method(SwigClassComplianceID.klass, "initialize", VALUEFUNC(_wrap_new_ComplianceID), -1);
  SwigClassComplianceID.mark = 0;
  SwigClassComplianceID.destroy = (void (*)(void *)) free_FIX_ComplianceID;
  SwigClassComplianceID.trackObjects = 0;
  
  SwigClassEmailThreadID.klass = rb_define_class_under(mQuickfix, "EmailThreadID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EmailThreadID, (void *) &SwigClassEmailThreadID);
  rb_define_alloc_func(SwigClassEmailThreadID.klass, _wrap_EmailThreadID_allocate);
  rb_define_method(SwigClassEmailThreadID.klass, "initialize", VALUEFUNC(_wrap_new_EmailThreadID), -1);
  SwigClassEmailThreadID.mark = 0;
  SwigClassEmailThreadID.destroy = (void (*)(void *)) free_FIX_EmailThreadID;
  SwigClassEmailThreadID.trackObjects = 0;
  
  SwigClassContAmtCurr.klass = rb_define_class_under(mQuickfix, "ContAmtCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContAmtCurr, (void *) &SwigClassContAmtCurr);
  rb_define_alloc_func(SwigClassContAmtCurr.klass, _wrap_ContAmtCurr_allocate);
  rb_define_method(SwigClassContAmtCurr.klass, "initialize", VALUEFUNC(_wrap_new_ContAmtCurr), -1);
  SwigClassContAmtCurr.mark = 0;
  SwigClassContAmtCurr.destroy = (void (*)(void *)) free_FIX_ContAmtCurr;
  SwigClassContAmtCurr.trackObjects = 0;
  
  SwigClassComplexEventType.klass = rb_define_class_under(mQuickfix, "ComplexEventType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventType, (void *) &SwigClassComplexEventType);
  rb_define_alloc_func(SwigClassComplexEventType.klass, _wrap_ComplexEventType_allocate);
  rb_define_method(SwigClassComplexEventType.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventType), -1);
  SwigClassComplexEventType.mark = 0;
  SwigClassComplexEventType.destroy = (void (*)(void *)) free_FIX_ComplexEventType;
  SwigClassComplexEventType.trackObjects = 0;
  
  SwigClassMassActionResponse.klass = rb_define_class_under(mQuickfix, "MassActionResponse", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionResponse, (void *) &SwigClassMassActionResponse);
  rb_define_alloc_func(SwigClassMassActionResponse.klass, _wrap_MassActionResponse_allocate);
  rb_define_method(SwigClassMassActionResponse.klass, "initialize", VALUEFUNC(_wrap_new_MassActionResponse), -1);
  SwigClassMassActionResponse.mark = 0;
  SwigClassMassActionResponse.destroy = (void (*)(void *)) free_FIX_MassActionResponse;
  SwigClassMassActionResponse.trackObjects = 0;
  
  SwigClassUnderlyingIssueDate.klass = rb_define_class_under(mQuickfix, "UnderlyingIssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingIssueDate, (void *) &SwigClassUnderlyingIssueDate);
  rb_define_alloc_func(SwigClassUnderlyingIssueDate.klass, _wrap_UnderlyingIssueDate_allocate);
  rb_define_method(SwigClassUnderlyingIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingIssueDate), -1);
  SwigClassUnderlyingIssueDate.mark = 0;
  SwigClassUnderlyingIssueDate.destroy = (void (*)(void *)) free_FIX_UnderlyingIssueDate;
  SwigClassUnderlyingIssueDate.trackObjects = 0;
  
  SwigClassSecurityRequestType.klass = rb_define_class_under(mQuickfix, "SecurityRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityRequestType, (void *) &SwigClassSecurityRequestType);
  rb_define_alloc_func(SwigClassSecurityRequestType.klass, _wrap_SecurityRequestType_allocate);
  rb_define_method(SwigClassSecurityRequestType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityRequestType), -1);
  SwigClassSecurityRequestType.mark = 0;
  SwigClassSecurityRequestType.destroy = (void (*)(void *)) free_FIX_SecurityRequestType;
  SwigClassSecurityRequestType.trackObjects = 0;
  
  SwigClassAllocInterestAtMaturity.klass = rb_define_class_under(mQuickfix, "AllocInterestAtMaturity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocInterestAtMaturity, (void *) &SwigClassAllocInterestAtMaturity);
  rb_define_alloc_func(SwigClassAllocInterestAtMaturity.klass, _wrap_AllocInterestAtMaturity_allocate);
  rb_define_method(SwigClassAllocInterestAtMaturity.klass, "initialize", VALUEFUNC(_wrap_new_AllocInterestAtMaturity), -1);
  SwigClassAllocInterestAtMaturity.mark = 0;
  SwigClassAllocInterestAtMaturity.destroy = (void (*)(void *)) free_FIX_AllocInterestAtMaturity;
  SwigClassAllocInterestAtMaturity.trackObjects = 0;
  
  SwigClassListRejectReason.klass = rb_define_class_under(mQuickfix, "ListRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListRejectReason, (void *) &SwigClassListRejectReason);
  rb_define_alloc_func(SwigClassListRejectReason.klass, _wrap_ListRejectReason_allocate);
  rb_define_method(SwigClassListRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_ListRejectReason), -1);
  SwigClassListRejectReason.mark = 0;
  SwigClassListRejectReason.destroy = (void (*)(void *)) free_FIX_ListRejectReason;
  SwigClassListRejectReason.trackObjects = 0;
  
  SwigClassDeskType.klass = rb_define_class_under(mQuickfix, "DeskType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskType, (void *) &SwigClassDeskType);
  rb_define_alloc_func(SwigClassDeskType.klass, _wrap_DeskType_allocate);
  rb_define_method(SwigClassDeskType.klass, "initialize", VALUEFUNC(_wrap_new_DeskType), -1);
  SwigClassDeskType.mark = 0;
  SwigClassDeskType.destroy = (void (*)(void *)) free_FIX_DeskType;
  SwigClassDeskType.trackObjects = 0;
  
  SwigClassSecondaryTradeReportID.klass = rb_define_class_under(mQuickfix, "SecondaryTradeReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradeReportID, (void *) &SwigClassSecondaryTradeReportID);
  rb_define_alloc_func(SwigClassSecondaryTradeReportID.klass, _wrap_SecondaryTradeReportID_allocate);
  rb_define_method(SwigClassSecondaryTradeReportID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradeReportID), -1);
  SwigClassSecondaryTradeReportID.mark = 0;
  SwigClassSecondaryTradeReportID.destroy = (void (*)(void *)) free_FIX_SecondaryTradeReportID;
  SwigClassSecondaryTradeReportID.trackObjects = 0;
  
  SwigClassSettlType.klass = rb_define_class_under(mQuickfix, "SettlType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlType, (void *) &SwigClassSettlType);
  rb_define_alloc_func(SwigClassSettlType.klass, _wrap_SettlType_allocate);
  rb_define_method(SwigClassSettlType.klass, "initialize", VALUEFUNC(_wrap_new_SettlType), -1);
  SwigClassSettlType.mark = 0;
  SwigClassSettlType.destroy = (void (*)(void *)) free_FIX_SettlType;
  SwigClassSettlType.trackObjects = 0;
  
  SwigClassOpenClose.klass = rb_define_class_under(mQuickfix, "OpenClose", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenClose, (void *) &SwigClassOpenClose);
  rb_define_alloc_func(SwigClassOpenClose.klass, _wrap_OpenClose_allocate);
  rb_define_method(SwigClassOpenClose.klass, "initialize", VALUEFUNC(_wrap_new_OpenClose), -1);
  SwigClassOpenClose.mark = 0;
  SwigClassOpenClose.destroy = (void (*)(void *)) free_FIX_OpenClose;
  SwigClassOpenClose.trackObjects = 0;
  
  SwigClassContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "ContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContractMultiplierUnit, (void *) &SwigClassContractMultiplierUnit);
  rb_define_alloc_func(SwigClassContractMultiplierUnit.klass, _wrap_ContractMultiplierUnit_allocate);
  rb_define_method(SwigClassContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_ContractMultiplierUnit), -1);
  SwigClassContractMultiplierUnit.mark = 0;
  SwigClassContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_ContractMultiplierUnit;
  SwigClassContractMultiplierUnit.trackObjects = 0;
  
  SwigClassSecondaryLowLimitPrice.klass = rb_define_class_under(mQuickfix, "SecondaryLowLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryLowLimitPrice, (void *) &SwigClassSecondaryLowLimitPrice);
  rb_define_alloc_func(SwigClassSecondaryLowLimitPrice.klass, _wrap_SecondaryLowLimitPrice_allocate);
  rb_define_method(SwigClassSecondaryLowLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryLowLimitPrice), -1);
  SwigClassSecondaryLowLimitPrice.mark = 0;
  SwigClassSecondaryLowLimitPrice.destroy = (void (*)(void *)) free_FIX_SecondaryLowLimitPrice;
  SwigClassSecondaryLowLimitPrice.trackObjects = 0;
  
  SwigClassExpQty.klass = rb_define_class_under(mQuickfix, "ExpQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpQty, (void *) &SwigClassExpQty);
  rb_define_alloc_func(SwigClassExpQty.klass, _wrap_ExpQty_allocate);
  rb_define_method(SwigClassExpQty.klass, "initialize", VALUEFUNC(_wrap_new_ExpQty), -1);
  SwigClassExpQty.mark = 0;
  SwigClassExpQty.destroy = (void (*)(void *)) free_FIX_ExpQty;
  SwigClassExpQty.trackObjects = 0;
  
  SwigClassNetworkRequestID.klass = rb_define_class_under(mQuickfix, "NetworkRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkRequestID, (void *) &SwigClassNetworkRequestID);
  rb_define_alloc_func(SwigClassNetworkRequestID.klass, _wrap_NetworkRequestID_allocate);
  rb_define_method(SwigClassNetworkRequestID.klass, "initialize", VALUEFUNC(_wrap_new_NetworkRequestID), -1);
  SwigClassNetworkRequestID.mark = 0;
  SwigClassNetworkRequestID.destroy = (void (*)(void *)) free_FIX_NetworkRequestID;
  SwigClassNetworkRequestID.trackObjects = 0;
  
  SwigClassTrdType.klass = rb_define_class_under(mQuickfix, "TrdType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdType, (void *) &SwigClassTrdType);
  rb_define_alloc_func(SwigClassTrdType.klass, _wrap_TrdType_allocate);
  rb_define_method(SwigClassTrdType.klass, "initialize", VALUEFUNC(_wrap_new_TrdType), -1);
  SwigClassTrdType.mark = 0;
  SwigClassTrdType.destroy = (void (*)(void *)) free_FIX_TrdType;
  SwigClassTrdType.trackObjects = 0;
  
  SwigClassNoUnderlyings.klass = rb_define_class_under(mQuickfix, "NoUnderlyings", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyings, (void *) &SwigClassNoUnderlyings);
  rb_define_alloc_func(SwigClassNoUnderlyings.klass, _wrap_NoUnderlyings_allocate);
  rb_define_method(SwigClassNoUnderlyings.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyings), -1);
  SwigClassNoUnderlyings.mark = 0;
  SwigClassNoUnderlyings.destroy = (void (*)(void *)) free_FIX_NoUnderlyings;
  SwigClassNoUnderlyings.trackObjects = 0;
  
  SwigClassMDMkt.klass = rb_define_class_under(mQuickfix, "MDMkt", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDMkt, (void *) &SwigClassMDMkt);
  rb_define_alloc_func(SwigClassMDMkt.klass, _wrap_MDMkt_allocate);
  rb_define_method(SwigClassMDMkt.klass, "initialize", VALUEFUNC(_wrap_new_MDMkt), -1);
  SwigClassMDMkt.mark = 0;
  SwigClassMDMkt.destroy = (void (*)(void *)) free_FIX_MDMkt;
  SwigClassMDMkt.trackObjects = 0;
  
  SwigClassLastMkt.klass = rb_define_class_under(mQuickfix, "LastMkt", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastMkt, (void *) &SwigClassLastMkt);
  rb_define_alloc_func(SwigClassLastMkt.klass, _wrap_LastMkt_allocate);
  rb_define_method(SwigClassLastMkt.klass, "initialize", VALUEFUNC(_wrap_new_LastMkt), -1);
  SwigClassLastMkt.mark = 0;
  SwigClassLastMkt.destroy = (void (*)(void *)) free_FIX_LastMkt;
  SwigClassLastMkt.trackObjects = 0;
  
  SwigClassRestructuringType.klass = rb_define_class_under(mQuickfix, "RestructuringType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RestructuringType, (void *) &SwigClassRestructuringType);
  rb_define_alloc_func(SwigClassRestructuringType.klass, _wrap_RestructuringType_allocate);
  rb_define_method(SwigClassRestructuringType.klass, "initialize", VALUEFUNC(_wrap_new_RestructuringType), -1);
  SwigClassRestructuringType.mark = 0;
  SwigClassRestructuringType.destroy = (void (*)(void *)) free_FIX_RestructuringType;
  SwigClassRestructuringType.trackObjects = 0;
  
  SwigClassNoStrikeRules.klass = rb_define_class_under(mQuickfix, "NoStrikeRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStrikeRules, (void *) &SwigClassNoStrikeRules);
  rb_define_alloc_func(SwigClassNoStrikeRules.klass, _wrap_NoStrikeRules_allocate);
  rb_define_method(SwigClassNoStrikeRules.klass, "initialize", VALUEFUNC(_wrap_new_NoStrikeRules), -1);
  SwigClassNoStrikeRules.mark = 0;
  SwigClassNoStrikeRules.destroy = (void (*)(void *)) free_FIX_NoStrikeRules;
  SwigClassNoStrikeRules.trackObjects = 0;
  
  SwigClassListName.klass = rb_define_class_under(mQuickfix, "ListName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListName, (void *) &SwigClassListName);
  rb_define_alloc_func(SwigClassListName.klass, _wrap_ListName_allocate);
  rb_define_method(SwigClassListName.klass, "initialize", VALUEFUNC(_wrap_new_ListName), -1);
  SwigClassListName.mark = 0;
  SwigClassListName.destroy = (void (*)(void *)) free_FIX_ListName;
  SwigClassListName.trackObjects = 0;
  
  SwigClassProgRptReqs.klass = rb_define_class_under(mQuickfix, "ProgRptReqs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProgRptReqs, (void *) &SwigClassProgRptReqs);
  rb_define_alloc_func(SwigClassProgRptReqs.klass, _wrap_ProgRptReqs_allocate);
  rb_define_method(SwigClassProgRptReqs.klass, "initialize", VALUEFUNC(_wrap_new_ProgRptReqs), -1);
  SwigClassProgRptReqs.mark = 0;
  SwigClassProgRptReqs.destroy = (void (*)(void *)) free_FIX_ProgRptReqs;
  SwigClassProgRptReqs.trackObjects = 0;
  
  SwigClassTradingSessionID.klass = rb_define_class_under(mQuickfix, "TradingSessionID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingSessionID, (void *) &SwigClassTradingSessionID);
  rb_define_alloc_func(SwigClassTradingSessionID.klass, _wrap_TradingSessionID_allocate);
  rb_define_method(SwigClassTradingSessionID.klass, "initialize", VALUEFUNC(_wrap_new_TradingSessionID), -1);
  SwigClassTradingSessionID.mark = 0;
  SwigClassTradingSessionID.destroy = (void (*)(void *)) free_FIX_TradingSessionID;
  SwigClassTradingSessionID.trackObjects = 0;
  
  SwigClassListOrderStatus.klass = rb_define_class_under(mQuickfix, "ListOrderStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListOrderStatus, (void *) &SwigClassListOrderStatus);
  rb_define_alloc_func(SwigClassListOrderStatus.klass, _wrap_ListOrderStatus_allocate);
  rb_define_method(SwigClassListOrderStatus.klass, "initialize", VALUEFUNC(_wrap_new_ListOrderStatus), -1);
  SwigClassListOrderStatus.mark = 0;
  SwigClassListOrderStatus.destroy = (void (*)(void *)) free_FIX_ListOrderStatus;
  SwigClassListOrderStatus.trackObjects = 0;
  
  SwigClassRegistStatus.klass = rb_define_class_under(mQuickfix, "RegistStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistStatus, (void *) &SwigClassRegistStatus);
  rb_define_alloc_func(SwigClassRegistStatus.klass, _wrap_RegistStatus_allocate);
  rb_define_method(SwigClassRegistStatus.klass, "initialize", VALUEFUNC(_wrap_new_RegistStatus), -1);
  SwigClassRegistStatus.mark = 0;
  SwigClassRegistStatus.destroy = (void (*)(void *)) free_FIX_RegistStatus;
  SwigClassRegistStatus.trackObjects = 0;
  
  SwigClassPosAmt.klass = rb_define_class_under(mQuickfix, "PosAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosAmt, (void *) &SwigClassPosAmt);
  rb_define_alloc_func(SwigClassPosAmt.klass, _wrap_PosAmt_allocate);
  rb_define_method(SwigClassPosAmt.klass, "initialize", VALUEFUNC(_wrap_new_PosAmt), -1);
  SwigClassPosAmt.mark = 0;
  SwigClassPosAmt.destroy = (void (*)(void *)) free_FIX_PosAmt;
  SwigClassPosAmt.trackObjects = 0;
  
  SwigClassUnderlyingPriceDeterminationMethod.klass = rb_define_class_under(mQuickfix, "UnderlyingPriceDeterminationMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod, (void *) &SwigClassUnderlyingPriceDeterminationMethod);
  rb_define_alloc_func(SwigClassUnderlyingPriceDeterminationMethod.klass, _wrap_UnderlyingPriceDeterminationMethod_allocate);
  rb_define_method(SwigClassUnderlyingPriceDeterminationMethod.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPriceDeterminationMethod), -1);
  SwigClassUnderlyingPriceDeterminationMethod.mark = 0;
  SwigClassUnderlyingPriceDeterminationMethod.destroy = (void (*)(void *)) free_FIX_UnderlyingPriceDeterminationMethod;
  SwigClassUnderlyingPriceDeterminationMethod.trackObjects = 0;
  
  SwigClassNoUnderlyingStips.klass = rb_define_class_under(mQuickfix, "NoUnderlyingStips", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingStips, (void *) &SwigClassNoUnderlyingStips);
  rb_define_alloc_func(SwigClassNoUnderlyingStips.klass, _wrap_NoUnderlyingStips_allocate);
  rb_define_method(SwigClassNoUnderlyingStips.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingStips), -1);
  SwigClassNoUnderlyingStips.mark = 0;
  SwigClassNoUnderlyingStips.destroy = (void (*)(void *)) free_FIX_NoUnderlyingStips;
  SwigClassNoUnderlyingStips.trackObjects = 0;
  
  SwigClassTradSesPreCloseTime.klass = rb_define_class_under(mQuickfix, "TradSesPreCloseTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesPreCloseTime, (void *) &SwigClassTradSesPreCloseTime);
  rb_define_alloc_func(SwigClassTradSesPreCloseTime.klass, _wrap_TradSesPreCloseTime_allocate);
  rb_define_method(SwigClassTradSesPreCloseTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesPreCloseTime), -1);
  SwigClassTradSesPreCloseTime.mark = 0;
  SwigClassTradSesPreCloseTime.destroy = (void (*)(void *)) free_FIX_TradSesPreCloseTime;
  SwigClassTradSesPreCloseTime.trackObjects = 0;
  
  SwigClassMassCancelRequestType.klass = rb_define_class_under(mQuickfix, "MassCancelRequestType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassCancelRequestType, (void *) &SwigClassMassCancelRequestType);
  rb_define_alloc_func(SwigClassMassCancelRequestType.klass, _wrap_MassCancelRequestType_allocate);
  rb_define_method(SwigClassMassCancelRequestType.klass, "initialize", VALUEFUNC(_wrap_new_MassCancelRequestType), -1);
  SwigClassMassCancelRequestType.mark = 0;
  SwigClassMassCancelRequestType.destroy = (void (*)(void *)) free_FIX_MassCancelRequestType;
  SwigClassMassCancelRequestType.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource, (void *) &SwigClassUnderlyingLegSecurityAltIDSource);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityAltIDSource.klass, _wrap_UnderlyingLegSecurityAltIDSource_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityAltIDSource), -1);
  SwigClassUnderlyingLegSecurityAltIDSource.mark = 0;
  SwigClassUnderlyingLegSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityAltIDSource;
  SwigClassUnderlyingLegSecurityAltIDSource.trackObjects = 0;
  
  SwigClassSettlPartyID.klass = rb_define_class_under(mQuickfix, "SettlPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartyID, (void *) &SwigClassSettlPartyID);
  rb_define_alloc_func(SwigClassSettlPartyID.klass, _wrap_SettlPartyID_allocate);
  rb_define_method(SwigClassSettlPartyID.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartyID), -1);
  SwigClassSettlPartyID.mark = 0;
  SwigClassSettlPartyID.destroy = (void (*)(void *)) free_FIX_SettlPartyID;
  SwigClassSettlPartyID.trackObjects = 0;
  
  SwigClassNoAffectedOrders.klass = rb_define_class_under(mQuickfix, "NoAffectedOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAffectedOrders, (void *) &SwigClassNoAffectedOrders);
  rb_define_alloc_func(SwigClassNoAffectedOrders.klass, _wrap_NoAffectedOrders_allocate);
  rb_define_method(SwigClassNoAffectedOrders.klass, "initialize", VALUEFUNC(_wrap_new_NoAffectedOrders), -1);
  SwigClassNoAffectedOrders.mark = 0;
  SwigClassNoAffectedOrders.destroy = (void (*)(void *)) free_FIX_NoAffectedOrders;
  SwigClassNoAffectedOrders.trackObjects = 0;
  
  SwigClassCashSettlAgentAcctNum.klass = rb_define_class_under(mQuickfix, "CashSettlAgentAcctNum", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentAcctNum, (void *) &SwigClassCashSettlAgentAcctNum);
  rb_define_alloc_func(SwigClassCashSettlAgentAcctNum.klass, _wrap_CashSettlAgentAcctNum_allocate);
  rb_define_method(SwigClassCashSettlAgentAcctNum.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentAcctNum), -1);
  SwigClassCashSettlAgentAcctNum.mark = 0;
  SwigClassCashSettlAgentAcctNum.destroy = (void (*)(void *)) free_FIX_CashSettlAgentAcctNum;
  SwigClassCashSettlAgentAcctNum.trackObjects = 0;
  
  SwigClassUnderlyingLegMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "UnderlyingLegMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear, (void *) &SwigClassUnderlyingLegMaturityMonthYear);
  rb_define_alloc_func(SwigClassUnderlyingLegMaturityMonthYear.klass, _wrap_UnderlyingLegMaturityMonthYear_allocate);
  rb_define_method(SwigClassUnderlyingLegMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegMaturityMonthYear), -1);
  SwigClassUnderlyingLegMaturityMonthYear.mark = 0;
  SwigClassUnderlyingLegMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_UnderlyingLegMaturityMonthYear;
  SwigClassUnderlyingLegMaturityMonthYear.trackObjects = 0;
  
  SwigClassNoLotTypeRules.klass = rb_define_class_under(mQuickfix, "NoLotTypeRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLotTypeRules, (void *) &SwigClassNoLotTypeRules);
  rb_define_alloc_func(SwigClassNoLotTypeRules.klass, _wrap_NoLotTypeRules_allocate);
  rb_define_method(SwigClassNoLotTypeRules.klass, "initialize", VALUEFUNC(_wrap_new_NoLotTypeRules), -1);
  SwigClassNoLotTypeRules.mark = 0;
  SwigClassNoLotTypeRules.destroy = (void (*)(void *)) free_FIX_NoLotTypeRules;
  SwigClassNoLotTypeRules.trackObjects = 0;
  
  SwigClassNoDates.klass = rb_define_class_under(mQuickfix, "NoDates", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDates, (void *) &SwigClassNoDates);
  rb_define_alloc_func(SwigClassNoDates.klass, _wrap_NoDates_allocate);
  rb_define_method(SwigClassNoDates.klass, "initialize", VALUEFUNC(_wrap_new_NoDates), -1);
  SwigClassNoDates.mark = 0;
  SwigClassNoDates.destroy = (void (*)(void *)) free_FIX_NoDates;
  SwigClassNoDates.trackObjects = 0;
  
  SwigClassCxlRejResponseTo.klass = rb_define_class_under(mQuickfix, "CxlRejResponseTo", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlRejResponseTo, (void *) &SwigClassCxlRejResponseTo);
  rb_define_alloc_func(SwigClassCxlRejResponseTo.klass, _wrap_CxlRejResponseTo_allocate);
  rb_define_method(SwigClassCxlRejResponseTo.klass, "initialize", VALUEFUNC(_wrap_new_CxlRejResponseTo), -1);
  SwigClassCxlRejResponseTo.mark = 0;
  SwigClassCxlRejResponseTo.destroy = (void (*)(void *)) free_FIX_CxlRejResponseTo;
  SwigClassCxlRejResponseTo.trackObjects = 0;
  
  SwigClassEffectiveTime.klass = rb_define_class_under(mQuickfix, "EffectiveTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EffectiveTime, (void *) &SwigClassEffectiveTime);
  rb_define_alloc_func(SwigClassEffectiveTime.klass, _wrap_EffectiveTime_allocate);
  rb_define_method(SwigClassEffectiveTime.klass, "initialize", VALUEFUNC(_wrap_new_EffectiveTime), -1);
  SwigClassEffectiveTime.mark = 0;
  SwigClassEffectiveTime.destroy = (void (*)(void *)) free_FIX_EffectiveTime;
  SwigClassEffectiveTime.trackObjects = 0;
  
  SwigClassGrossTradeAmt.klass = rb_define_class_under(mQuickfix, "GrossTradeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__GrossTradeAmt, (void *) &SwigClassGrossTradeAmt);
  rb_define_alloc_func(SwigClassGrossTradeAmt.klass, _wrap_GrossTradeAmt_allocate);
  rb_define_method(SwigClassGrossTradeAmt.klass, "initialize", VALUEFUNC(_wrap_new_GrossTradeAmt), -1);
  SwigClassGrossTradeAmt.mark = 0;
  SwigClassGrossTradeAmt.destroy = (void (*)(void *)) free_FIX_GrossTradeAmt;
  SwigClassGrossTradeAmt.trackObjects = 0;
  
  SwigClassSecurityListDesc.klass = rb_define_class_under(mQuickfix, "SecurityListDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListDesc, (void *) &SwigClassSecurityListDesc);
  rb_define_alloc_func(SwigClassSecurityListDesc.klass, _wrap_SecurityListDesc_allocate);
  rb_define_method(SwigClassSecurityListDesc.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListDesc), -1);
  SwigClassSecurityListDesc.mark = 0;
  SwigClassSecurityListDesc.destroy = (void (*)(void *)) free_FIX_SecurityListDesc;
  SwigClassSecurityListDesc.trackObjects = 0;
  
  SwigClassNotAffectedOrderID.klass = rb_define_class_under(mQuickfix, "NotAffectedOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotAffectedOrderID, (void *) &SwigClassNotAffectedOrderID);
  rb_define_alloc_func(SwigClassNotAffectedOrderID.klass, _wrap_NotAffectedOrderID_allocate);
  rb_define_method(SwigClassNotAffectedOrderID.klass, "initialize", VALUEFUNC(_wrap_new_NotAffectedOrderID), -1);
  SwigClassNotAffectedOrderID.mark = 0;
  SwigClassNotAffectedOrderID.destroy = (void (*)(void *)) free_FIX_NotAffectedOrderID;
  SwigClassNotAffectedOrderID.trackObjects = 0;
  
  SwigClassDerivativeStrikeValue.klass = rb_define_class_under(mQuickfix, "DerivativeStrikeValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikeValue, (void *) &SwigClassDerivativeStrikeValue);
  rb_define_alloc_func(SwigClassDerivativeStrikeValue.klass, _wrap_DerivativeStrikeValue_allocate);
  rb_define_method(SwigClassDerivativeStrikeValue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikeValue), -1);
  SwigClassDerivativeStrikeValue.mark = 0;
  SwigClassDerivativeStrikeValue.destroy = (void (*)(void *)) free_FIX_DerivativeStrikeValue;
  SwigClassDerivativeStrikeValue.trackObjects = 0;
  
  SwigClassNoPosAmt.klass = rb_define_class_under(mQuickfix, "NoPosAmt", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPosAmt, (void *) &SwigClassNoPosAmt);
  rb_define_alloc_func(SwigClassNoPosAmt.klass, _wrap_NoPosAmt_allocate);
  rb_define_method(SwigClassNoPosAmt.klass, "initialize", VALUEFUNC(_wrap_new_NoPosAmt), -1);
  SwigClassNoPosAmt.mark = 0;
  SwigClassNoPosAmt.destroy = (void (*)(void *)) free_FIX_NoPosAmt;
  SwigClassNoPosAmt.trackObjects = 0;
  
  SwigClassLegCreditRating.klass = rb_define_class_under(mQuickfix, "LegCreditRating", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCreditRating, (void *) &SwigClassLegCreditRating);
  rb_define_alloc_func(SwigClassLegCreditRating.klass, _wrap_LegCreditRating_allocate);
  rb_define_method(SwigClassLegCreditRating.klass, "initialize", VALUEFUNC(_wrap_new_LegCreditRating), -1);
  SwigClassLegCreditRating.mark = 0;
  SwigClassLegCreditRating.destroy = (void (*)(void *)) free_FIX_LegCreditRating;
  SwigClassLegCreditRating.trackObjects = 0;
  
  SwigClassBidForwardPoints2.klass = rb_define_class_under(mQuickfix, "BidForwardPoints2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidForwardPoints2, (void *) &SwigClassBidForwardPoints2);
  rb_define_alloc_func(SwigClassBidForwardPoints2.klass, _wrap_BidForwardPoints2_allocate);
  rb_define_method(SwigClassBidForwardPoints2.klass, "initialize", VALUEFUNC(_wrap_new_BidForwardPoints2), -1);
  SwigClassBidForwardPoints2.mark = 0;
  SwigClassBidForwardPoints2.destroy = (void (*)(void *)) free_FIX_BidForwardPoints2;
  SwigClassBidForwardPoints2.trackObjects = 0;
  
  SwigClassSettlDate.klass = rb_define_class_under(mQuickfix, "SettlDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDate, (void *) &SwigClassSettlDate);
  rb_define_alloc_func(SwigClassSettlDate.klass, _wrap_SettlDate_allocate);
  rb_define_method(SwigClassSettlDate.klass, "initialize", VALUEFUNC(_wrap_new_SettlDate), -1);
  SwigClassSettlDate.mark = 0;
  SwigClassSettlDate.destroy = (void (*)(void *)) free_FIX_SettlDate;
  SwigClassSettlDate.trackObjects = 0;
  
  SwigClassClientID.klass = rb_define_class_under(mQuickfix, "ClientID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClientID, (void *) &SwigClassClientID);
  rb_define_alloc_func(SwigClassClientID.klass, _wrap_ClientID_allocate);
  rb_define_method(SwigClassClientID.klass, "initialize", VALUEFUNC(_wrap_new_ClientID), -1);
  SwigClassClientID.mark = 0;
  SwigClassClientID.destroy = (void (*)(void *)) free_FIX_ClientID;
  SwigClassClientID.trackObjects = 0;
  
  SwigClassQuoteCancelType.klass = rb_define_class_under(mQuickfix, "QuoteCancelType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteCancelType, (void *) &SwigClassQuoteCancelType);
  rb_define_alloc_func(SwigClassQuoteCancelType.klass, _wrap_QuoteCancelType_allocate);
  rb_define_method(SwigClassQuoteCancelType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteCancelType), -1);
  SwigClassQuoteCancelType.mark = 0;
  SwigClassQuoteCancelType.destroy = (void (*)(void *)) free_FIX_QuoteCancelType;
  SwigClassQuoteCancelType.trackObjects = 0;
  
  SwigClassStipulationType.klass = rb_define_class_under(mQuickfix, "StipulationType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StipulationType, (void *) &SwigClassStipulationType);
  rb_define_alloc_func(SwigClassStipulationType.klass, _wrap_StipulationType_allocate);
  rb_define_method(SwigClassStipulationType.klass, "initialize", VALUEFUNC(_wrap_new_StipulationType), -1);
  SwigClassStipulationType.mark = 0;
  SwigClassStipulationType.destroy = (void (*)(void *)) free_FIX_StipulationType;
  SwigClassStipulationType.trackObjects = 0;
  
  SwigClassOutMainCntryUIndex.klass = rb_define_class_under(mQuickfix, "OutMainCntryUIndex", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OutMainCntryUIndex, (void *) &SwigClassOutMainCntryUIndex);
  rb_define_alloc_func(SwigClassOutMainCntryUIndex.klass, _wrap_OutMainCntryUIndex_allocate);
  rb_define_method(SwigClassOutMainCntryUIndex.klass, "initialize", VALUEFUNC(_wrap_new_OutMainCntryUIndex), -1);
  SwigClassOutMainCntryUIndex.mark = 0;
  SwigClassOutMainCntryUIndex.destroy = (void (*)(void *)) free_FIX_OutMainCntryUIndex;
  SwigClassOutMainCntryUIndex.trackObjects = 0;
  
  SwigClassLegSettlmntTyp.klass = rb_define_class_under(mQuickfix, "LegSettlmntTyp", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlmntTyp, (void *) &SwigClassLegSettlmntTyp);
  rb_define_alloc_func(SwigClassLegSettlmntTyp.klass, _wrap_LegSettlmntTyp_allocate);
  rb_define_method(SwigClassLegSettlmntTyp.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlmntTyp), -1);
  SwigClassLegSettlmntTyp.mark = 0;
  SwigClassLegSettlmntTyp.destroy = (void (*)(void *)) free_FIX_LegSettlmntTyp;
  SwigClassLegSettlmntTyp.trackObjects = 0;
  
  SwigClassDerivativeNTPositionLimit.klass = rb_define_class_under(mQuickfix, "DerivativeNTPositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeNTPositionLimit, (void *) &SwigClassDerivativeNTPositionLimit);
  rb_define_alloc_func(SwigClassDerivativeNTPositionLimit.klass, _wrap_DerivativeNTPositionLimit_allocate);
  rb_define_method(SwigClassDerivativeNTPositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeNTPositionLimit), -1);
  SwigClassDerivativeNTPositionLimit.mark = 0;
  SwigClassDerivativeNTPositionLimit.destroy = (void (*)(void *)) free_FIX_DerivativeNTPositionLimit;
  SwigClassDerivativeNTPositionLimit.trackObjects = 0;
  
  SwigClassPriceQuoteMethod.klass = rb_define_class_under(mQuickfix, "PriceQuoteMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceQuoteMethod, (void *) &SwigClassPriceQuoteMethod);
  rb_define_alloc_func(SwigClassPriceQuoteMethod.klass, _wrap_PriceQuoteMethod_allocate);
  rb_define_method(SwigClassPriceQuoteMethod.klass, "initialize", VALUEFUNC(_wrap_new_PriceQuoteMethod), -1);
  SwigClassPriceQuoteMethod.mark = 0;
  SwigClassPriceQuoteMethod.destroy = (void (*)(void *)) free_FIX_PriceQuoteMethod;
  SwigClassPriceQuoteMethod.trackObjects = 0;
  
  SwigClassLowLimitPrice.klass = rb_define_class_under(mQuickfix, "LowLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LowLimitPrice, (void *) &SwigClassLowLimitPrice);
  rb_define_alloc_func(SwigClassLowLimitPrice.klass, _wrap_LowLimitPrice_allocate);
  rb_define_method(SwigClassLowLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_LowLimitPrice), -1);
  SwigClassLowLimitPrice.mark = 0;
  SwigClassLowLimitPrice.destroy = (void (*)(void *)) free_FIX_LowLimitPrice;
  SwigClassLowLimitPrice.trackObjects = 0;
  
  SwigClassLegUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "LegUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegUnitOfMeasure, (void *) &SwigClassLegUnitOfMeasure);
  rb_define_alloc_func(SwigClassLegUnitOfMeasure.klass, _wrap_LegUnitOfMeasure_allocate);
  rb_define_method(SwigClassLegUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_LegUnitOfMeasure), -1);
  SwigClassLegUnitOfMeasure.mark = 0;
  SwigClassLegUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_LegUnitOfMeasure;
  SwigClassLegUnitOfMeasure.trackObjects = 0;
  
  SwigClassSessionRejectReason.klass = rb_define_class_under(mQuickfix, "SessionRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionRejectReason, (void *) &SwigClassSessionRejectReason);
  rb_define_alloc_func(SwigClassSessionRejectReason.klass, _wrap_SessionRejectReason_allocate);
  rb_define_method(SwigClassSessionRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_SessionRejectReason), -1);
  SwigClassSessionRejectReason.mark = 0;
  SwigClassSessionRejectReason.destroy = (void (*)(void *)) free_FIX_SessionRejectReason;
  SwigClassSessionRejectReason.trackObjects = 0;
  
  SwigClassDeliveryType.klass = rb_define_class_under(mQuickfix, "DeliveryType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliveryType, (void *) &SwigClassDeliveryType);
  rb_define_alloc_func(SwigClassDeliveryType.klass, _wrap_DeliveryType_allocate);
  rb_define_method(SwigClassDeliveryType.klass, "initialize", VALUEFUNC(_wrap_new_DeliveryType), -1);
  SwigClassDeliveryType.mark = 0;
  SwigClassDeliveryType.destroy = (void (*)(void *)) free_FIX_DeliveryType;
  SwigClassDeliveryType.trackObjects = 0;
  
  SwigClassAllocPrice.klass = rb_define_class_under(mQuickfix, "AllocPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocPrice, (void *) &SwigClassAllocPrice);
  rb_define_alloc_func(SwigClassAllocPrice.klass, _wrap_AllocPrice_allocate);
  rb_define_method(SwigClassAllocPrice.klass, "initialize", VALUEFUNC(_wrap_new_AllocPrice), -1);
  SwigClassAllocPrice.mark = 0;
  SwigClassAllocPrice.destroy = (void (*)(void *)) free_FIX_AllocPrice;
  SwigClassAllocPrice.trackObjects = 0;
  
  SwigClassNoBidComponents.klass = rb_define_class_under(mQuickfix, "NoBidComponents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoBidComponents, (void *) &SwigClassNoBidComponents);
  rb_define_alloc_func(SwigClassNoBidComponents.klass, _wrap_NoBidComponents_allocate);
  rb_define_method(SwigClassNoBidComponents.klass, "initialize", VALUEFUNC(_wrap_new_NoBidComponents), -1);
  SwigClassNoBidComponents.mark = 0;
  SwigClassNoBidComponents.destroy = (void (*)(void *)) free_FIX_NoBidComponents;
  SwigClassNoBidComponents.trackObjects = 0;
  
  SwigClassQuoteQualifier.klass = rb_define_class_under(mQuickfix, "QuoteQualifier", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteQualifier, (void *) &SwigClassQuoteQualifier);
  rb_define_alloc_func(SwigClassQuoteQualifier.klass, _wrap_QuoteQualifier_allocate);
  rb_define_method(SwigClassQuoteQualifier.klass, "initialize", VALUEFUNC(_wrap_new_QuoteQualifier), -1);
  SwigClassQuoteQualifier.mark = 0;
  SwigClassQuoteQualifier.destroy = (void (*)(void *)) free_FIX_QuoteQualifier;
  SwigClassQuoteQualifier.trackObjects = 0;
  
  SwigClassScope.klass = rb_define_class_under(mQuickfix, "Scope", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Scope, (void *) &SwigClassScope);
  rb_define_alloc_func(SwigClassScope.klass, _wrap_Scope_allocate);
  rb_define_method(SwigClassScope.klass, "initialize", VALUEFUNC(_wrap_new_Scope), -1);
  SwigClassScope.mark = 0;
  SwigClassScope.destroy = (void (*)(void *)) free_FIX_Scope;
  SwigClassScope.trackObjects = 0;
  
  SwigClassNoSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSecurityAltID, (void *) &SwigClassNoSecurityAltID);
  rb_define_alloc_func(SwigClassNoSecurityAltID.klass, _wrap_NoSecurityAltID_allocate);
  rb_define_method(SwigClassNoSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoSecurityAltID), -1);
  SwigClassNoSecurityAltID.mark = 0;
  SwigClassNoSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoSecurityAltID;
  SwigClassNoSecurityAltID.trackObjects = 0;
  
  SwigClassRootPartySubID.klass = rb_define_class_under(mQuickfix, "RootPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartySubID, (void *) &SwigClassRootPartySubID);
  rb_define_alloc_func(SwigClassRootPartySubID.klass, _wrap_RootPartySubID_allocate);
  rb_define_method(SwigClassRootPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_RootPartySubID), -1);
  SwigClassRootPartySubID.mark = 0;
  SwigClassRootPartySubID.destroy = (void (*)(void *)) free_FIX_RootPartySubID;
  SwigClassRootPartySubID.trackObjects = 0;
  
  SwigClassDeliverToLocationID.klass = rb_define_class_under(mQuickfix, "DeliverToLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliverToLocationID, (void *) &SwigClassDeliverToLocationID);
  rb_define_alloc_func(SwigClassDeliverToLocationID.klass, _wrap_DeliverToLocationID_allocate);
  rb_define_method(SwigClassDeliverToLocationID.klass, "initialize", VALUEFUNC(_wrap_new_DeliverToLocationID), -1);
  SwigClassDeliverToLocationID.mark = 0;
  SwigClassDeliverToLocationID.destroy = (void (*)(void *)) free_FIX_DeliverToLocationID;
  SwigClassDeliverToLocationID.trackObjects = 0;
  
  SwigClassDeleteReason.klass = rb_define_class_under(mQuickfix, "DeleteReason", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeleteReason, (void *) &SwigClassDeleteReason);
  rb_define_alloc_func(SwigClassDeleteReason.klass, _wrap_DeleteReason_allocate);
  rb_define_method(SwigClassDeleteReason.klass, "initialize", VALUEFUNC(_wrap_new_DeleteReason), -1);
  SwigClassDeleteReason.mark = 0;
  SwigClassDeleteReason.destroy = (void (*)(void *)) free_FIX_DeleteReason;
  SwigClassDeleteReason.trackObjects = 0;
  
  SwigClassBidSpotRate.klass = rb_define_class_under(mQuickfix, "BidSpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidSpotRate, (void *) &SwigClassBidSpotRate);
  rb_define_alloc_func(SwigClassBidSpotRate.klass, _wrap_BidSpotRate_allocate);
  rb_define_method(SwigClassBidSpotRate.klass, "initialize", VALUEFUNC(_wrap_new_BidSpotRate), -1);
  SwigClassBidSpotRate.mark = 0;
  SwigClassBidSpotRate.destroy = (void (*)(void *)) free_FIX_BidSpotRate;
  SwigClassBidSpotRate.trackObjects = 0;
  
  SwigClassNested4PartyID.klass = rb_define_class_under(mQuickfix, "Nested4PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartyID, (void *) &SwigClassNested4PartyID);
  rb_define_alloc_func(SwigClassNested4PartyID.klass, _wrap_Nested4PartyID_allocate);
  rb_define_method(SwigClassNested4PartyID.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartyID), -1);
  SwigClassNested4PartyID.mark = 0;
  SwigClassNested4PartyID.destroy = (void (*)(void *)) free_FIX_Nested4PartyID;
  SwigClassNested4PartyID.trackObjects = 0;
  
  SwigClassInViewOfCommon.klass = rb_define_class_under(mQuickfix, "InViewOfCommon", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InViewOfCommon, (void *) &SwigClassInViewOfCommon);
  rb_define_alloc_func(SwigClassInViewOfCommon.klass, _wrap_InViewOfCommon_allocate);
  rb_define_method(SwigClassInViewOfCommon.klass, "initialize", VALUEFUNC(_wrap_new_InViewOfCommon), -1);
  SwigClassInViewOfCommon.mark = 0;
  SwigClassInViewOfCommon.destroy = (void (*)(void *)) free_FIX_InViewOfCommon;
  SwigClassInViewOfCommon.trackObjects = 0;
  
  SwigClassUnderlyingSettlPrice.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlPrice, (void *) &SwigClassUnderlyingSettlPrice);
  rb_define_alloc_func(SwigClassUnderlyingSettlPrice.klass, _wrap_UnderlyingSettlPrice_allocate);
  rb_define_method(SwigClassUnderlyingSettlPrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlPrice), -1);
  SwigClassUnderlyingSettlPrice.mark = 0;
  SwigClassUnderlyingSettlPrice.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlPrice;
  SwigClassUnderlyingSettlPrice.trackObjects = 0;
  
  SwigClassRegistRejReasonText.klass = rb_define_class_under(mQuickfix, "RegistRejReasonText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistRejReasonText, (void *) &SwigClassRegistRejReasonText);
  rb_define_alloc_func(SwigClassRegistRejReasonText.klass, _wrap_RegistRejReasonText_allocate);
  rb_define_method(SwigClassRegistRejReasonText.klass, "initialize", VALUEFUNC(_wrap_new_RegistRejReasonText), -1);
  SwigClassRegistRejReasonText.mark = 0;
  SwigClassRegistRejReasonText.destroy = (void (*)(void *)) free_FIX_RegistRejReasonText;
  SwigClassRegistRejReasonText.trackObjects = 0;
  
  SwigClassNoSides.klass = rb_define_class_under(mQuickfix, "NoSides", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSides, (void *) &SwigClassNoSides);
  rb_define_alloc_func(SwigClassNoSides.klass, _wrap_NoSides_allocate);
  rb_define_method(SwigClassNoSides.klass, "initialize", VALUEFUNC(_wrap_new_NoSides), -1);
  SwigClassNoSides.mark = 0;
  SwigClassNoSides.destroy = (void (*)(void *)) free_FIX_NoSides;
  SwigClassNoSides.trackObjects = 0;
  
  SwigClassLegAllocAccount.klass = rb_define_class_under(mQuickfix, "LegAllocAccount", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocAccount, (void *) &SwigClassLegAllocAccount);
  rb_define_alloc_func(SwigClassLegAllocAccount.klass, _wrap_LegAllocAccount_allocate);
  rb_define_method(SwigClassLegAllocAccount.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocAccount), -1);
  SwigClassLegAllocAccount.mark = 0;
  SwigClassLegAllocAccount.destroy = (void (*)(void *)) free_FIX_LegAllocAccount;
  SwigClassLegAllocAccount.trackObjects = 0;
  
  SwigClassLegSecurityDesc.klass = rb_define_class_under(mQuickfix, "LegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityDesc, (void *) &SwigClassLegSecurityDesc);
  rb_define_alloc_func(SwigClassLegSecurityDesc.klass, _wrap_LegSecurityDesc_allocate);
  rb_define_method(SwigClassLegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityDesc), -1);
  SwigClassLegSecurityDesc.mark = 0;
  SwigClassLegSecurityDesc.destroy = (void (*)(void *)) free_FIX_LegSecurityDesc;
  SwigClassLegSecurityDesc.trackObjects = 0;
  
  SwigClassClOrdLinkID.klass = rb_define_class_under(mQuickfix, "ClOrdLinkID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClOrdLinkID, (void *) &SwigClassClOrdLinkID);
  rb_define_alloc_func(SwigClassClOrdLinkID.klass, _wrap_ClOrdLinkID_allocate);
  rb_define_method(SwigClassClOrdLinkID.klass, "initialize", VALUEFUNC(_wrap_new_ClOrdLinkID), -1);
  SwigClassClOrdLinkID.mark = 0;
  SwigClassClOrdLinkID.destroy = (void (*)(void *)) free_FIX_ClOrdLinkID;
  SwigClassClOrdLinkID.trackObjects = 0;
  
  SwigClassOrigSendingTime.klass = rb_define_class_under(mQuickfix, "OrigSendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigSendingTime, (void *) &SwigClassOrigSendingTime);
  rb_define_alloc_func(SwigClassOrigSendingTime.klass, _wrap_OrigSendingTime_allocate);
  rb_define_method(SwigClassOrigSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_OrigSendingTime), -1);
  SwigClassOrigSendingTime.mark = 0;
  SwigClassOrigSendingTime.destroy = (void (*)(void *)) free_FIX_OrigSendingTime;
  SwigClassOrigSendingTime.trackObjects = 0;
  
  SwigClassEncodedLegIssuerLen.klass = rb_define_class_under(mQuickfix, "EncodedLegIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegIssuerLen, (void *) &SwigClassEncodedLegIssuerLen);
  rb_define_alloc_func(SwigClassEncodedLegIssuerLen.klass, _wrap_EncodedLegIssuerLen_allocate);
  rb_define_method(SwigClassEncodedLegIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegIssuerLen), -1);
  SwigClassEncodedLegIssuerLen.mark = 0;
  SwigClassEncodedLegIssuerLen.destroy = (void (*)(void *)) free_FIX_EncodedLegIssuerLen;
  SwigClassEncodedLegIssuerLen.trackObjects = 0;
  
  SwigClassOrderID.klass = rb_define_class_under(mQuickfix, "OrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderID, (void *) &SwigClassOrderID);
  rb_define_alloc_func(SwigClassOrderID.klass, _wrap_OrderID_allocate);
  rb_define_method(SwigClassOrderID.klass, "initialize", VALUEFUNC(_wrap_new_OrderID), -1);
  SwigClassOrderID.mark = 0;
  SwigClassOrderID.destroy = (void (*)(void *)) free_FIX_OrderID;
  SwigClassOrderID.trackObjects = 0;
  
  SwigClassSecurityType.klass = rb_define_class_under(mQuickfix, "SecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityType, (void *) &SwigClassSecurityType);
  rb_define_alloc_func(SwigClassSecurityType.klass, _wrap_SecurityType_allocate);
  rb_define_method(SwigClassSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityType), -1);
  SwigClassSecurityType.mark = 0;
  SwigClassSecurityType.destroy = (void (*)(void *)) free_FIX_SecurityType;
  SwigClassSecurityType.trackObjects = 0;
  
  SwigClassRoundingDirection.klass = rb_define_class_under(mQuickfix, "RoundingDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoundingDirection, (void *) &SwigClassRoundingDirection);
  rb_define_alloc_func(SwigClassRoundingDirection.klass, _wrap_RoundingDirection_allocate);
  rb_define_method(SwigClassRoundingDirection.klass, "initialize", VALUEFUNC(_wrap_new_RoundingDirection), -1);
  SwigClassRoundingDirection.mark = 0;
  SwigClassRoundingDirection.destroy = (void (*)(void *)) free_FIX_RoundingDirection;
  SwigClassRoundingDirection.trackObjects = 0;
  
  SwigClassFillExecID.klass = rb_define_class_under(mQuickfix, "FillExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillExecID, (void *) &SwigClassFillExecID);
  rb_define_alloc_func(SwigClassFillExecID.klass, _wrap_FillExecID_allocate);
  rb_define_method(SwigClassFillExecID.klass, "initialize", VALUEFUNC(_wrap_new_FillExecID), -1);
  SwigClassFillExecID.mark = 0;
  SwigClassFillExecID.destroy = (void (*)(void *)) free_FIX_FillExecID;
  SwigClassFillExecID.trackObjects = 0;
  
  SwigClassNoEvents.klass = rb_define_class_under(mQuickfix, "NoEvents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoEvents, (void *) &SwigClassNoEvents);
  rb_define_alloc_func(SwigClassNoEvents.klass, _wrap_NoEvents_allocate);
  rb_define_method(SwigClassNoEvents.klass, "initialize", VALUEFUNC(_wrap_new_NoEvents), -1);
  SwigClassNoEvents.mark = 0;
  SwigClassNoEvents.destroy = (void (*)(void *)) free_FIX_NoEvents;
  SwigClassNoEvents.trackObjects = 0;
  
  SwigClassRoundLot.klass = rb_define_class_under(mQuickfix, "RoundLot", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoundLot, (void *) &SwigClassRoundLot);
  rb_define_alloc_func(SwigClassRoundLot.klass, _wrap_RoundLot_allocate);
  rb_define_method(SwigClassRoundLot.klass, "initialize", VALUEFUNC(_wrap_new_RoundLot), -1);
  SwigClassRoundLot.mark = 0;
  SwigClassRoundLot.destroy = (void (*)(void *)) free_FIX_RoundLot;
  SwigClassRoundLot.trackObjects = 0;
  
  SwigClassMDEntrySize.klass = rb_define_class_under(mQuickfix, "MDEntrySize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntrySize, (void *) &SwigClassMDEntrySize);
  rb_define_alloc_func(SwigClassMDEntrySize.klass, _wrap_MDEntrySize_allocate);
  rb_define_method(SwigClassMDEntrySize.klass, "initialize", VALUEFUNC(_wrap_new_MDEntrySize), -1);
  SwigClassMDEntrySize.mark = 0;
  SwigClassMDEntrySize.destroy = (void (*)(void *)) free_FIX_MDEntrySize;
  SwigClassMDEntrySize.trackObjects = 0;
  
  SwigClassEncodedIssuerLen.klass = rb_define_class_under(mQuickfix, "EncodedIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedIssuerLen, (void *) &SwigClassEncodedIssuerLen);
  rb_define_alloc_func(SwigClassEncodedIssuerLen.klass, _wrap_EncodedIssuerLen_allocate);
  rb_define_method(SwigClassEncodedIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedIssuerLen), -1);
  SwigClassEncodedIssuerLen.mark = 0;
  SwigClassEncodedIssuerLen.destroy = (void (*)(void *)) free_FIX_EncodedIssuerLen;
  SwigClassEncodedIssuerLen.trackObjects = 0;
  
  SwigClassDerivativePriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "DerivativePriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty, (void *) &SwigClassDerivativePriceUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassDerivativePriceUnitOfMeasureQty.klass, _wrap_DerivativePriceUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassDerivativePriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePriceUnitOfMeasureQty), -1);
  SwigClassDerivativePriceUnitOfMeasureQty.mark = 0;
  SwigClassDerivativePriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_DerivativePriceUnitOfMeasureQty;
  SwigClassDerivativePriceUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassTimeUnit.klass = rb_define_class_under(mQuickfix, "TimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeUnit, (void *) &SwigClassTimeUnit);
  rb_define_alloc_func(SwigClassTimeUnit.klass, _wrap_TimeUnit_allocate);
  rb_define_method(SwigClassTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_TimeUnit), -1);
  SwigClassTimeUnit.mark = 0;
  SwigClassTimeUnit.destroy = (void (*)(void *)) free_FIX_TimeUnit;
  SwigClassTimeUnit.trackObjects = 0;
  
  SwigClassTotNoOrders.klass = rb_define_class_under(mQuickfix, "TotNoOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoOrders, (void *) &SwigClassTotNoOrders);
  rb_define_alloc_func(SwigClassTotNoOrders.klass, _wrap_TotNoOrders_allocate);
  rb_define_method(SwigClassTotNoOrders.klass, "initialize", VALUEFUNC(_wrap_new_TotNoOrders), -1);
  SwigClassTotNoOrders.mark = 0;
  SwigClassTotNoOrders.destroy = (void (*)(void *)) free_FIX_TotNoOrders;
  SwigClassTotNoOrders.trackObjects = 0;
  
  SwigClassLegSwapType.klass = rb_define_class_under(mQuickfix, "LegSwapType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSwapType, (void *) &SwigClassLegSwapType);
  rb_define_alloc_func(SwigClassLegSwapType.klass, _wrap_LegSwapType_allocate);
  rb_define_method(SwigClassLegSwapType.klass, "initialize", VALUEFUNC(_wrap_new_LegSwapType), -1);
  SwigClassLegSwapType.mark = 0;
  SwigClassLegSwapType.destroy = (void (*)(void *)) free_FIX_LegSwapType;
  SwigClassLegSwapType.trackObjects = 0;
  
  SwigClassIOITransType.klass = rb_define_class_under(mQuickfix, "IOITransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOITransType, (void *) &SwigClassIOITransType);
  rb_define_alloc_func(SwigClassIOITransType.klass, _wrap_IOITransType_allocate);
  rb_define_method(SwigClassIOITransType.klass, "initialize", VALUEFUNC(_wrap_new_IOITransType), -1);
  SwigClassIOITransType.mark = 0;
  SwigClassIOITransType.destroy = (void (*)(void *)) free_FIX_IOITransType;
  SwigClassIOITransType.trackObjects = 0;
  
  SwigClassRawDataLength.klass = rb_define_class_under(mQuickfix, "RawDataLength", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RawDataLength, (void *) &SwigClassRawDataLength);
  rb_define_alloc_func(SwigClassRawDataLength.klass, _wrap_RawDataLength_allocate);
  rb_define_method(SwigClassRawDataLength.klass, "initialize", VALUEFUNC(_wrap_new_RawDataLength), -1);
  SwigClassRawDataLength.mark = 0;
  SwigClassRawDataLength.destroy = (void (*)(void *)) free_FIX_RawDataLength;
  SwigClassRawDataLength.trackObjects = 0;
  
  SwigClassUnderlyingSecurityType.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityType, (void *) &SwigClassUnderlyingSecurityType);
  rb_define_alloc_func(SwigClassUnderlyingSecurityType.klass, _wrap_UnderlyingSecurityType_allocate);
  rb_define_method(SwigClassUnderlyingSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityType), -1);
  SwigClassUnderlyingSecurityType.mark = 0;
  SwigClassUnderlyingSecurityType.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityType;
  SwigClassUnderlyingSecurityType.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID, (void *) &SwigClassUnderlyingLegSecurityAltID);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityAltID.klass, _wrap_UnderlyingLegSecurityAltID_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityAltID), -1);
  SwigClassUnderlyingLegSecurityAltID.mark = 0;
  SwigClassUnderlyingLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityAltID;
  SwigClassUnderlyingLegSecurityAltID.trackObjects = 0;
  
  SwigClassSecurityReportID.klass = rb_define_class_under(mQuickfix, "SecurityReportID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityReportID, (void *) &SwigClassSecurityReportID);
  rb_define_alloc_func(SwigClassSecurityReportID.klass, _wrap_SecurityReportID_allocate);
  rb_define_method(SwigClassSecurityReportID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityReportID), -1);
  SwigClassSecurityReportID.mark = 0;
  SwigClassSecurityReportID.destroy = (void (*)(void *)) free_FIX_SecurityReportID;
  SwigClassSecurityReportID.trackObjects = 0;
  
  SwigClassTotNumReports.klass = rb_define_class_under(mQuickfix, "TotNumReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNumReports, (void *) &SwigClassTotNumReports);
  rb_define_alloc_func(SwigClassTotNumReports.klass, _wrap_TotNumReports_allocate);
  rb_define_method(SwigClassTotNumReports.klass, "initialize", VALUEFUNC(_wrap_new_TotNumReports), -1);
  SwigClassTotNumReports.mark = 0;
  SwigClassTotNumReports.destroy = (void (*)(void *)) free_FIX_TotNumReports;
  SwigClassTotNumReports.trackObjects = 0;
  
  SwigClassTotalNumPosReports.klass = rb_define_class_under(mQuickfix, "TotalNumPosReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNumPosReports, (void *) &SwigClassTotalNumPosReports);
  rb_define_alloc_func(SwigClassTotalNumPosReports.klass, _wrap_TotalNumPosReports_allocate);
  rb_define_method(SwigClassTotalNumPosReports.klass, "initialize", VALUEFUNC(_wrap_new_TotalNumPosReports), -1);
  SwigClassTotalNumPosReports.mark = 0;
  SwigClassTotalNumPosReports.destroy = (void (*)(void *)) free_FIX_TotalNumPosReports;
  SwigClassTotalNumPosReports.trackObjects = 0;
  
  SwigClassSecurityReqID.klass = rb_define_class_under(mQuickfix, "SecurityReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityReqID, (void *) &SwigClassSecurityReqID);
  rb_define_alloc_func(SwigClassSecurityReqID.klass, _wrap_SecurityReqID_allocate);
  rb_define_method(SwigClassSecurityReqID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityReqID), -1);
  SwigClassSecurityReqID.mark = 0;
  SwigClassSecurityReqID.destroy = (void (*)(void *)) free_FIX_SecurityReqID;
  SwigClassSecurityReqID.trackObjects = 0;
  
  SwigClassPosReqResult.klass = rb_define_class_under(mQuickfix, "PosReqResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqResult, (void *) &SwigClassPosReqResult);
  rb_define_alloc_func(SwigClassPosReqResult.klass, _wrap_PosReqResult_allocate);
  rb_define_method(SwigClassPosReqResult.klass, "initialize", VALUEFUNC(_wrap_new_PosReqResult), -1);
  SwigClassPosReqResult.mark = 0;
  SwigClassPosReqResult.destroy = (void (*)(void *)) free_FIX_PosReqResult;
  SwigClassPosReqResult.trackObjects = 0;
  
  SwigClassLegOfferForwardPoints.klass = rb_define_class_under(mQuickfix, "LegOfferForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOfferForwardPoints, (void *) &SwigClassLegOfferForwardPoints);
  rb_define_alloc_func(SwigClassLegOfferForwardPoints.klass, _wrap_LegOfferForwardPoints_allocate);
  rb_define_method(SwigClassLegOfferForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LegOfferForwardPoints), -1);
  SwigClassLegOfferForwardPoints.mark = 0;
  SwigClassLegOfferForwardPoints.destroy = (void (*)(void *)) free_FIX_LegOfferForwardPoints;
  SwigClassLegOfferForwardPoints.trackObjects = 0;
  
  SwigClassAllowableOneSidednessCurr.klass = rb_define_class_under(mQuickfix, "AllowableOneSidednessCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllowableOneSidednessCurr, (void *) &SwigClassAllowableOneSidednessCurr);
  rb_define_alloc_func(SwigClassAllowableOneSidednessCurr.klass, _wrap_AllowableOneSidednessCurr_allocate);
  rb_define_method(SwigClassAllowableOneSidednessCurr.klass, "initialize", VALUEFUNC(_wrap_new_AllowableOneSidednessCurr), -1);
  SwigClassAllowableOneSidednessCurr.mark = 0;
  SwigClassAllowableOneSidednessCurr.destroy = (void (*)(void *)) free_FIX_AllowableOneSidednessCurr;
  SwigClassAllowableOneSidednessCurr.trackObjects = 0;
  
  SwigClassAffectedOrderID.klass = rb_define_class_under(mQuickfix, "AffectedOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AffectedOrderID, (void *) &SwigClassAffectedOrderID);
  rb_define_alloc_func(SwigClassAffectedOrderID.klass, _wrap_AffectedOrderID_allocate);
  rb_define_method(SwigClassAffectedOrderID.klass, "initialize", VALUEFUNC(_wrap_new_AffectedOrderID), -1);
  SwigClassAffectedOrderID.mark = 0;
  SwigClassAffectedOrderID.destroy = (void (*)(void *)) free_FIX_AffectedOrderID;
  SwigClassAffectedOrderID.trackObjects = 0;
  
  SwigClassUnderlyingCountryOfIssue.klass = rb_define_class_under(mQuickfix, "UnderlyingCountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCountryOfIssue, (void *) &SwigClassUnderlyingCountryOfIssue);
  rb_define_alloc_func(SwigClassUnderlyingCountryOfIssue.klass, _wrap_UnderlyingCountryOfIssue_allocate);
  rb_define_method(SwigClassUnderlyingCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCountryOfIssue), -1);
  SwigClassUnderlyingCountryOfIssue.mark = 0;
  SwigClassUnderlyingCountryOfIssue.destroy = (void (*)(void *)) free_FIX_UnderlyingCountryOfIssue;
  SwigClassUnderlyingCountryOfIssue.trackObjects = 0;
  
  SwigClassUnderlyingRepurchaseRate.klass = rb_define_class_under(mQuickfix, "UnderlyingRepurchaseRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRepurchaseRate, (void *) &SwigClassUnderlyingRepurchaseRate);
  rb_define_alloc_func(SwigClassUnderlyingRepurchaseRate.klass, _wrap_UnderlyingRepurchaseRate_allocate);
  rb_define_method(SwigClassUnderlyingRepurchaseRate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRepurchaseRate), -1);
  SwigClassUnderlyingRepurchaseRate.mark = 0;
  SwigClassUnderlyingRepurchaseRate.destroy = (void (*)(void *)) free_FIX_UnderlyingRepurchaseRate;
  SwigClassUnderlyingRepurchaseRate.trackObjects = 0;
  
  SwigClassLastMsgSeqNumProcessed.klass = rb_define_class_under(mQuickfix, "LastMsgSeqNumProcessed", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastMsgSeqNumProcessed, (void *) &SwigClassLastMsgSeqNumProcessed);
  rb_define_alloc_func(SwigClassLastMsgSeqNumProcessed.klass, _wrap_LastMsgSeqNumProcessed_allocate);
  rb_define_method(SwigClassLastMsgSeqNumProcessed.klass, "initialize", VALUEFUNC(_wrap_new_LastMsgSeqNumProcessed), -1);
  SwigClassLastMsgSeqNumProcessed.mark = 0;
  SwigClassLastMsgSeqNumProcessed.destroy = (void (*)(void *)) free_FIX_LastMsgSeqNumProcessed;
  SwigClassLastMsgSeqNumProcessed.trackObjects = 0;
  
  SwigClassUnderlyingCFICode.klass = rb_define_class_under(mQuickfix, "UnderlyingCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCFICode, (void *) &SwigClassUnderlyingCFICode);
  rb_define_alloc_func(SwigClassUnderlyingCFICode.klass, _wrap_UnderlyingCFICode_allocate);
  rb_define_method(SwigClassUnderlyingCFICode.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCFICode), -1);
  SwigClassUnderlyingCFICode.mark = 0;
  SwigClassUnderlyingCFICode.destroy = (void (*)(void *)) free_FIX_UnderlyingCFICode;
  SwigClassUnderlyingCFICode.trackObjects = 0;
  
  SwigClassDerivativeOptAttribute.klass = rb_define_class_under(mQuickfix, "DerivativeOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeOptAttribute, (void *) &SwigClassDerivativeOptAttribute);
  rb_define_alloc_func(SwigClassDerivativeOptAttribute.klass, _wrap_DerivativeOptAttribute_allocate);
  rb_define_method(SwigClassDerivativeOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeOptAttribute), -1);
  SwigClassDerivativeOptAttribute.mark = 0;
  SwigClassDerivativeOptAttribute.destroy = (void (*)(void *)) free_FIX_DerivativeOptAttribute;
  SwigClassDerivativeOptAttribute.trackObjects = 0;
  
  SwigClassPegSecurityID.klass = rb_define_class_under(mQuickfix, "PegSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSecurityID, (void *) &SwigClassPegSecurityID);
  rb_define_alloc_func(SwigClassPegSecurityID.klass, _wrap_PegSecurityID_allocate);
  rb_define_method(SwigClassPegSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_PegSecurityID), -1);
  SwigClassPegSecurityID.mark = 0;
  SwigClassPegSecurityID.destroy = (void (*)(void *)) free_FIX_PegSecurityID;
  SwigClassPegSecurityID.trackObjects = 0;
  
  SwigClassHostCrossID.klass = rb_define_class_under(mQuickfix, "HostCrossID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HostCrossID, (void *) &SwigClassHostCrossID);
  rb_define_alloc_func(SwigClassHostCrossID.klass, _wrap_HostCrossID_allocate);
  rb_define_method(SwigClassHostCrossID.klass, "initialize", VALUEFUNC(_wrap_new_HostCrossID), -1);
  SwigClassHostCrossID.mark = 0;
  SwigClassHostCrossID.destroy = (void (*)(void *)) free_FIX_HostCrossID;
  SwigClassHostCrossID.trackObjects = 0;
  
  SwigClassExecInstValue.klass = rb_define_class_under(mQuickfix, "ExecInstValue", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecInstValue, (void *) &SwigClassExecInstValue);
  rb_define_alloc_func(SwigClassExecInstValue.klass, _wrap_ExecInstValue_allocate);
  rb_define_method(SwigClassExecInstValue.klass, "initialize", VALUEFUNC(_wrap_new_ExecInstValue), -1);
  SwigClassExecInstValue.mark = 0;
  SwigClassExecInstValue.destroy = (void (*)(void *)) free_FIX_ExecInstValue;
  SwigClassExecInstValue.trackObjects = 0;
  
  SwigClassDerivativeOptPayAmount.klass = rb_define_class_under(mQuickfix, "DerivativeOptPayAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeOptPayAmount, (void *) &SwigClassDerivativeOptPayAmount);
  rb_define_alloc_func(SwigClassDerivativeOptPayAmount.klass, _wrap_DerivativeOptPayAmount_allocate);
  rb_define_method(SwigClassDerivativeOptPayAmount.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeOptPayAmount), -1);
  SwigClassDerivativeOptPayAmount.mark = 0;
  SwigClassDerivativeOptPayAmount.destroy = (void (*)(void *)) free_FIX_DerivativeOptPayAmount;
  SwigClassDerivativeOptPayAmount.trackObjects = 0;
  
  SwigClassUnderlyingCouponRate.klass = rb_define_class_under(mQuickfix, "UnderlyingCouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCouponRate, (void *) &SwigClassUnderlyingCouponRate);
  rb_define_alloc_func(SwigClassUnderlyingCouponRate.klass, _wrap_UnderlyingCouponRate_allocate);
  rb_define_method(SwigClassUnderlyingCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCouponRate), -1);
  SwigClassUnderlyingCouponRate.mark = 0;
  SwigClassUnderlyingCouponRate.destroy = (void (*)(void *)) free_FIX_UnderlyingCouponRate;
  SwigClassUnderlyingCouponRate.trackObjects = 0;
  
  SwigClassSettlInstMode.klass = rb_define_class_under(mQuickfix, "SettlInstMode", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstMode, (void *) &SwigClassSettlInstMode);
  rb_define_alloc_func(SwigClassSettlInstMode.klass, _wrap_SettlInstMode_allocate);
  rb_define_method(SwigClassSettlInstMode.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstMode), -1);
  SwigClassSettlInstMode.mark = 0;
  SwigClassSettlInstMode.destroy = (void (*)(void *)) free_FIX_SettlInstMode;
  SwigClassSettlInstMode.trackObjects = 0;
  
  SwigClassSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "SecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityAltIDSource, (void *) &SwigClassSecurityAltIDSource);
  rb_define_alloc_func(SwigClassSecurityAltIDSource.klass, _wrap_SecurityAltIDSource_allocate);
  rb_define_method(SwigClassSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_SecurityAltIDSource), -1);
  SwigClassSecurityAltIDSource.mark = 0;
  SwigClassSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_SecurityAltIDSource;
  SwigClassSecurityAltIDSource.trackObjects = 0;
  
  SwigClassPreviouslyReported.klass = rb_define_class_under(mQuickfix, "PreviouslyReported", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PreviouslyReported, (void *) &SwigClassPreviouslyReported);
  rb_define_alloc_func(SwigClassPreviouslyReported.klass, _wrap_PreviouslyReported_allocate);
  rb_define_method(SwigClassPreviouslyReported.klass, "initialize", VALUEFUNC(_wrap_new_PreviouslyReported), -1);
  SwigClassPreviouslyReported.mark = 0;
  SwigClassPreviouslyReported.destroy = (void (*)(void *)) free_FIX_PreviouslyReported;
  SwigClassPreviouslyReported.trackObjects = 0;
  
  SwigClassRptSys.klass = rb_define_class_under(mQuickfix, "RptSys", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RptSys, (void *) &SwigClassRptSys);
  rb_define_alloc_func(SwigClassRptSys.klass, _wrap_RptSys_allocate);
  rb_define_method(SwigClassRptSys.klass, "initialize", VALUEFUNC(_wrap_new_RptSys), -1);
  SwigClassRptSys.mark = 0;
  SwigClassRptSys.destroy = (void (*)(void *)) free_FIX_RptSys;
  SwigClassRptSys.trackObjects = 0;
  
  SwigClassNoNested2PartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNested2PartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested2PartySubIDs, (void *) &SwigClassNoNested2PartySubIDs);
  rb_define_alloc_func(SwigClassNoNested2PartySubIDs.klass, _wrap_NoNested2PartySubIDs_allocate);
  rb_define_method(SwigClassNoNested2PartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested2PartySubIDs), -1);
  SwigClassNoNested2PartySubIDs.mark = 0;
  SwigClassNoNested2PartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNested2PartySubIDs;
  SwigClassNoNested2PartySubIDs.trackObjects = 0;
  
  SwigClassRefAllocID.klass = rb_define_class_under(mQuickfix, "RefAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefAllocID, (void *) &SwigClassRefAllocID);
  rb_define_alloc_func(SwigClassRefAllocID.klass, _wrap_RefAllocID_allocate);
  rb_define_method(SwigClassRefAllocID.klass, "initialize", VALUEFUNC(_wrap_new_RefAllocID), -1);
  SwigClassRefAllocID.mark = 0;
  SwigClassRefAllocID.destroy = (void (*)(void *)) free_FIX_RefAllocID;
  SwigClassRefAllocID.trackObjects = 0;
  
  SwigClassDefOfferSize.klass = rb_define_class_under(mQuickfix, "DefOfferSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefOfferSize, (void *) &SwigClassDefOfferSize);
  rb_define_alloc_func(SwigClassDefOfferSize.klass, _wrap_DefOfferSize_allocate);
  rb_define_method(SwigClassDefOfferSize.klass, "initialize", VALUEFUNC(_wrap_new_DefOfferSize), -1);
  SwigClassDefOfferSize.mark = 0;
  SwigClassDefOfferSize.destroy = (void (*)(void *)) free_FIX_DefOfferSize;
  SwigClassDefOfferSize.trackObjects = 0;
  
  SwigClassProductComplex.klass = rb_define_class_under(mQuickfix, "ProductComplex", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProductComplex, (void *) &SwigClassProductComplex);
  rb_define_alloc_func(SwigClassProductComplex.klass, _wrap_ProductComplex_allocate);
  rb_define_method(SwigClassProductComplex.klass, "initialize", VALUEFUNC(_wrap_new_ProductComplex), -1);
  SwigClassProductComplex.mark = 0;
  SwigClassProductComplex.destroy = (void (*)(void *)) free_FIX_ProductComplex;
  SwigClassProductComplex.trackObjects = 0;
  
  SwigClassCustOrderHandlingInst.klass = rb_define_class_under(mQuickfix, "CustOrderHandlingInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustOrderHandlingInst, (void *) &SwigClassCustOrderHandlingInst);
  rb_define_alloc_func(SwigClassCustOrderHandlingInst.klass, _wrap_CustOrderHandlingInst_allocate);
  rb_define_method(SwigClassCustOrderHandlingInst.klass, "initialize", VALUEFUNC(_wrap_new_CustOrderHandlingInst), -1);
  SwigClassCustOrderHandlingInst.mark = 0;
  SwigClassCustOrderHandlingInst.destroy = (void (*)(void *)) free_FIX_CustOrderHandlingInst;
  SwigClassCustOrderHandlingInst.trackObjects = 0;
  
  SwigClassMDPriceLevel.klass = rb_define_class_under(mQuickfix, "MDPriceLevel", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDPriceLevel, (void *) &SwigClassMDPriceLevel);
  rb_define_alloc_func(SwigClassMDPriceLevel.klass, _wrap_MDPriceLevel_allocate);
  rb_define_method(SwigClassMDPriceLevel.klass, "initialize", VALUEFUNC(_wrap_new_MDPriceLevel), -1);
  SwigClassMDPriceLevel.mark = 0;
  SwigClassMDPriceLevel.destroy = (void (*)(void *)) free_FIX_MDPriceLevel;
  SwigClassMDPriceLevel.trackObjects = 0;
  
  SwigClassLegOptionRatio.klass = rb_define_class_under(mQuickfix, "LegOptionRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOptionRatio, (void *) &SwigClassLegOptionRatio);
  rb_define_alloc_func(SwigClassLegOptionRatio.klass, _wrap_LegOptionRatio_allocate);
  rb_define_method(SwigClassLegOptionRatio.klass, "initialize", VALUEFUNC(_wrap_new_LegOptionRatio), -1);
  SwigClassLegOptionRatio.mark = 0;
  SwigClassLegOptionRatio.destroy = (void (*)(void *)) free_FIX_LegOptionRatio;
  SwigClassLegOptionRatio.trackObjects = 0;
  
  SwigClassSecurityStatus.klass = rb_define_class_under(mQuickfix, "SecurityStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityStatus, (void *) &SwigClassSecurityStatus);
  rb_define_alloc_func(SwigClassSecurityStatus.klass, _wrap_SecurityStatus_allocate);
  rb_define_method(SwigClassSecurityStatus.klass, "initialize", VALUEFUNC(_wrap_new_SecurityStatus), -1);
  SwigClassSecurityStatus.mark = 0;
  SwigClassSecurityStatus.destroy = (void (*)(void *)) free_FIX_SecurityStatus;
  SwigClassSecurityStatus.trackObjects = 0;
  
  SwigClassLegRefID.klass = rb_define_class_under(mQuickfix, "LegRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRefID, (void *) &SwigClassLegRefID);
  rb_define_alloc_func(SwigClassLegRefID.klass, _wrap_LegRefID_allocate);
  rb_define_method(SwigClassLegRefID.klass, "initialize", VALUEFUNC(_wrap_new_LegRefID), -1);
  SwigClassLegRefID.mark = 0;
  SwigClassLegRefID.destroy = (void (*)(void *)) free_FIX_LegRefID;
  SwigClassLegRefID.trackObjects = 0;
  
  SwigClassDividendYield.klass = rb_define_class_under(mQuickfix, "DividendYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DividendYield, (void *) &SwigClassDividendYield);
  rb_define_alloc_func(SwigClassDividendYield.klass, _wrap_DividendYield_allocate);
  rb_define_method(SwigClassDividendYield.klass, "initialize", VALUEFUNC(_wrap_new_DividendYield), -1);
  SwigClassDividendYield.mark = 0;
  SwigClassDividendYield.destroy = (void (*)(void *)) free_FIX_DividendYield;
  SwigClassDividendYield.trackObjects = 0;
  
  SwigClassDerivativeInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType, (void *) &SwigClassDerivativeInstrumentPartySubIDType);
  rb_define_alloc_func(SwigClassDerivativeInstrumentPartySubIDType.klass, _wrap_DerivativeInstrumentPartySubIDType_allocate);
  rb_define_method(SwigClassDerivativeInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartySubIDType), -1);
  SwigClassDerivativeInstrumentPartySubIDType.mark = 0;
  SwigClassDerivativeInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartySubIDType;
  SwigClassDerivativeInstrumentPartySubIDType.trackObjects = 0;
  
  SwigClassEndStrikePxRange.klass = rb_define_class_under(mQuickfix, "EndStrikePxRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndStrikePxRange, (void *) &SwigClassEndStrikePxRange);
  rb_define_alloc_func(SwigClassEndStrikePxRange.klass, _wrap_EndStrikePxRange_allocate);
  rb_define_method(SwigClassEndStrikePxRange.klass, "initialize", VALUEFUNC(_wrap_new_EndStrikePxRange), -1);
  SwigClassEndStrikePxRange.mark = 0;
  SwigClassEndStrikePxRange.destroy = (void (*)(void *)) free_FIX_EndStrikePxRange;
  SwigClassEndStrikePxRange.trackObjects = 0;
  
  SwigClassDisplayQty.klass = rb_define_class_under(mQuickfix, "DisplayQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayQty, (void *) &SwigClassDisplayQty);
  rb_define_alloc_func(SwigClassDisplayQty.klass, _wrap_DisplayQty_allocate);
  rb_define_method(SwigClassDisplayQty.klass, "initialize", VALUEFUNC(_wrap_new_DisplayQty), -1);
  SwigClassDisplayQty.mark = 0;
  SwigClassDisplayQty.destroy = (void (*)(void *)) free_FIX_DisplayQty;
  SwigClassDisplayQty.trackObjects = 0;
  
  SwigClassLegSecuritySubType.klass = rb_define_class_under(mQuickfix, "LegSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecuritySubType, (void *) &SwigClassLegSecuritySubType);
  rb_define_alloc_func(SwigClassLegSecuritySubType.klass, _wrap_LegSecuritySubType_allocate);
  rb_define_method(SwigClassLegSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_LegSecuritySubType), -1);
  SwigClassLegSecuritySubType.mark = 0;
  SwigClassLegSecuritySubType.destroy = (void (*)(void *)) free_FIX_LegSecuritySubType;
  SwigClassLegSecuritySubType.trackObjects = 0;
  
  SwigClassProcessCode.klass = rb_define_class_under(mQuickfix, "ProcessCode", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProcessCode, (void *) &SwigClassProcessCode);
  rb_define_alloc_func(SwigClassProcessCode.klass, _wrap_ProcessCode_allocate);
  rb_define_method(SwigClassProcessCode.klass, "initialize", VALUEFUNC(_wrap_new_ProcessCode), -1);
  SwigClassProcessCode.mark = 0;
  SwigClassProcessCode.destroy = (void (*)(void *)) free_FIX_ProcessCode;
  SwigClassProcessCode.trackObjects = 0;
  
  SwigClassExecInst.klass = rb_define_class_under(mQuickfix, "ExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecInst, (void *) &SwigClassExecInst);
  rb_define_alloc_func(SwigClassExecInst.klass, _wrap_ExecInst_allocate);
  rb_define_method(SwigClassExecInst.klass, "initialize", VALUEFUNC(_wrap_new_ExecInst), -1);
  SwigClassExecInst.mark = 0;
  SwigClassExecInst.destroy = (void (*)(void *)) free_FIX_ExecInst;
  SwigClassExecInst.trackObjects = 0;
  
  SwigClassTradSesEndTime.klass = rb_define_class_under(mQuickfix, "TradSesEndTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesEndTime, (void *) &SwigClassTradSesEndTime);
  rb_define_alloc_func(SwigClassTradSesEndTime.klass, _wrap_TradSesEndTime_allocate);
  rb_define_method(SwigClassTradSesEndTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesEndTime), -1);
  SwigClassTradSesEndTime.mark = 0;
  SwigClassTradSesEndTime.destroy = (void (*)(void *)) free_FIX_TradSesEndTime;
  SwigClassTradSesEndTime.trackObjects = 0;
  
  SwigClassOrigTime.klass = rb_define_class_under(mQuickfix, "OrigTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTime, (void *) &SwigClassOrigTime);
  rb_define_alloc_func(SwigClassOrigTime.klass, _wrap_OrigTime_allocate);
  rb_define_method(SwigClassOrigTime.klass, "initialize", VALUEFUNC(_wrap_new_OrigTime), -1);
  SwigClassOrigTime.mark = 0;
  SwigClassOrigTime.destroy = (void (*)(void *)) free_FIX_OrigTime;
  SwigClassOrigTime.trackObjects = 0;
  
  SwigClassExecValuationPoint.klass = rb_define_class_under(mQuickfix, "ExecValuationPoint", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecValuationPoint, (void *) &SwigClassExecValuationPoint);
  rb_define_alloc_func(SwigClassExecValuationPoint.klass, _wrap_ExecValuationPoint_allocate);
  rb_define_method(SwigClassExecValuationPoint.klass, "initialize", VALUEFUNC(_wrap_new_ExecValuationPoint), -1);
  SwigClassExecValuationPoint.mark = 0;
  SwigClassExecValuationPoint.destroy = (void (*)(void *)) free_FIX_ExecValuationPoint;
  SwigClassExecValuationPoint.trackObjects = 0;
  
  SwigClassExecType.klass = rb_define_class_under(mQuickfix, "ExecType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecType, (void *) &SwigClassExecType);
  rb_define_alloc_func(SwigClassExecType.klass, _wrap_ExecType_allocate);
  rb_define_method(SwigClassExecType.klass, "initialize", VALUEFUNC(_wrap_new_ExecType), -1);
  SwigClassExecType.mark = 0;
  SwigClassExecType.destroy = (void (*)(void *)) free_FIX_ExecType;
  SwigClassExecType.trackObjects = 0;
  
  SwigClassNested4PartyRole.klass = rb_define_class_under(mQuickfix, "Nested4PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartyRole, (void *) &SwigClassNested4PartyRole);
  rb_define_alloc_func(SwigClassNested4PartyRole.klass, _wrap_Nested4PartyRole_allocate);
  rb_define_method(SwigClassNested4PartyRole.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartyRole), -1);
  SwigClassNested4PartyRole.mark = 0;
  SwigClassNested4PartyRole.destroy = (void (*)(void *)) free_FIX_Nested4PartyRole;
  SwigClassNested4PartyRole.trackObjects = 0;
  
  SwigClassMultilegModel.klass = rb_define_class_under(mQuickfix, "MultilegModel", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultilegModel, (void *) &SwigClassMultilegModel);
  rb_define_alloc_func(SwigClassMultilegModel.klass, _wrap_MultilegModel_allocate);
  rb_define_method(SwigClassMultilegModel.klass, "initialize", VALUEFUNC(_wrap_new_MultilegModel), -1);
  SwigClassMultilegModel.mark = 0;
  SwigClassMultilegModel.destroy = (void (*)(void *)) free_FIX_MultilegModel;
  SwigClassMultilegModel.trackObjects = 0;
  
  SwigClassSecurityGroup.klass = rb_define_class_under(mQuickfix, "SecurityGroup", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityGroup, (void *) &SwigClassSecurityGroup);
  rb_define_alloc_func(SwigClassSecurityGroup.klass, _wrap_SecurityGroup_allocate);
  rb_define_method(SwigClassSecurityGroup.klass, "initialize", VALUEFUNC(_wrap_new_SecurityGroup), -1);
  SwigClassSecurityGroup.mark = 0;
  SwigClassSecurityGroup.destroy = (void (*)(void *)) free_FIX_SecurityGroup;
  SwigClassSecurityGroup.trackObjects = 0;
  
  SwigClassEventType.klass = rb_define_class_under(mQuickfix, "EventType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventType, (void *) &SwigClassEventType);
  rb_define_alloc_func(SwigClassEventType.klass, _wrap_EventType_allocate);
  rb_define_method(SwigClassEventType.klass, "initialize", VALUEFUNC(_wrap_new_EventType), -1);
  SwigClassEventType.mark = 0;
  SwigClassEventType.destroy = (void (*)(void *)) free_FIX_EventType;
  SwigClassEventType.trackObjects = 0;
  
  SwigClassTradeAllocIndicator.klass = rb_define_class_under(mQuickfix, "TradeAllocIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeAllocIndicator, (void *) &SwigClassTradeAllocIndicator);
  rb_define_alloc_func(SwigClassTradeAllocIndicator.klass, _wrap_TradeAllocIndicator_allocate);
  rb_define_method(SwigClassTradeAllocIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TradeAllocIndicator), -1);
  SwigClassTradeAllocIndicator.mark = 0;
  SwigClassTradeAllocIndicator.destroy = (void (*)(void *)) free_FIX_TradeAllocIndicator;
  SwigClassTradeAllocIndicator.trackObjects = 0;
  
  SwigClassYieldCalcDate.klass = rb_define_class_under(mQuickfix, "YieldCalcDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldCalcDate, (void *) &SwigClassYieldCalcDate);
  rb_define_alloc_func(SwigClassYieldCalcDate.klass, _wrap_YieldCalcDate_allocate);
  rb_define_method(SwigClassYieldCalcDate.klass, "initialize", VALUEFUNC(_wrap_new_YieldCalcDate), -1);
  SwigClassYieldCalcDate.mark = 0;
  SwigClassYieldCalcDate.destroy = (void (*)(void *)) free_FIX_YieldCalcDate;
  SwigClassYieldCalcDate.trackObjects = 0;
  
  SwigClassValueOfFutures.klass = rb_define_class_under(mQuickfix, "ValueOfFutures", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ValueOfFutures, (void *) &SwigClassValueOfFutures);
  rb_define_alloc_func(SwigClassValueOfFutures.klass, _wrap_ValueOfFutures_allocate);
  rb_define_method(SwigClassValueOfFutures.klass, "initialize", VALUEFUNC(_wrap_new_ValueOfFutures), -1);
  SwigClassValueOfFutures.mark = 0;
  SwigClassValueOfFutures.destroy = (void (*)(void *)) free_FIX_ValueOfFutures;
  SwigClassValueOfFutures.trackObjects = 0;
  
  SwigClassLegSide.klass = rb_define_class_under(mQuickfix, "LegSide", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSide, (void *) &SwigClassLegSide);
  rb_define_alloc_func(SwigClassLegSide.klass, _wrap_LegSide_allocate);
  rb_define_method(SwigClassLegSide.klass, "initialize", VALUEFUNC(_wrap_new_LegSide), -1);
  SwigClassLegSide.mark = 0;
  SwigClassLegSide.destroy = (void (*)(void *)) free_FIX_LegSide;
  SwigClassLegSide.trackObjects = 0;
  
  SwigClassUserStatus.klass = rb_define_class_under(mQuickfix, "UserStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserStatus, (void *) &SwigClassUserStatus);
  rb_define_alloc_func(SwigClassUserStatus.klass, _wrap_UserStatus_allocate);
  rb_define_method(SwigClassUserStatus.klass, "initialize", VALUEFUNC(_wrap_new_UserStatus), -1);
  SwigClassUserStatus.mark = 0;
  SwigClassUserStatus.destroy = (void (*)(void *)) free_FIX_UserStatus;
  SwigClassUserStatus.trackObjects = 0;
  
  SwigClassSideValue1.klass = rb_define_class_under(mQuickfix, "SideValue1", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideValue1, (void *) &SwigClassSideValue1);
  rb_define_alloc_func(SwigClassSideValue1.klass, _wrap_SideValue1_allocate);
  rb_define_method(SwigClassSideValue1.klass, "initialize", VALUEFUNC(_wrap_new_SideValue1), -1);
  SwigClassSideValue1.mark = 0;
  SwigClassSideValue1.destroy = (void (*)(void *)) free_FIX_SideValue1;
  SwigClassSideValue1.trackObjects = 0;
  
  SwigClassCxlQty.klass = rb_define_class_under(mQuickfix, "CxlQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlQty, (void *) &SwigClassCxlQty);
  rb_define_alloc_func(SwigClassCxlQty.klass, _wrap_CxlQty_allocate);
  rb_define_method(SwigClassCxlQty.klass, "initialize", VALUEFUNC(_wrap_new_CxlQty), -1);
  SwigClassCxlQty.mark = 0;
  SwigClassCxlQty.destroy = (void (*)(void *)) free_FIX_CxlQty;
  SwigClassCxlQty.trackObjects = 0;
  
  SwigClassSecurityResponseID.klass = rb_define_class_under(mQuickfix, "SecurityResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityResponseID, (void *) &SwigClassSecurityResponseID);
  rb_define_alloc_func(SwigClassSecurityResponseID.klass, _wrap_SecurityResponseID_allocate);
  rb_define_method(SwigClassSecurityResponseID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityResponseID), -1);
  SwigClassSecurityResponseID.mark = 0;
  SwigClassSecurityResponseID.destroy = (void (*)(void *)) free_FIX_SecurityResponseID;
  SwigClassSecurityResponseID.trackObjects = 0;
  
  SwigClassInstrRegistry.klass = rb_define_class_under(mQuickfix, "InstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrRegistry, (void *) &SwigClassInstrRegistry);
  rb_define_alloc_func(SwigClassInstrRegistry.klass, _wrap_InstrRegistry_allocate);
  rb_define_method(SwigClassInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_InstrRegistry), -1);
  SwigClassInstrRegistry.mark = 0;
  SwigClassInstrRegistry.destroy = (void (*)(void *)) free_FIX_InstrRegistry;
  SwigClassInstrRegistry.trackObjects = 0;
  
  SwigClassStreamAsgnRptID.klass = rb_define_class_under(mQuickfix, "StreamAsgnRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnRptID, (void *) &SwigClassStreamAsgnRptID);
  rb_define_alloc_func(SwigClassStreamAsgnRptID.klass, _wrap_StreamAsgnRptID_allocate);
  rb_define_method(SwigClassStreamAsgnRptID.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnRptID), -1);
  SwigClassStreamAsgnRptID.mark = 0;
  SwigClassStreamAsgnRptID.destroy = (void (*)(void *)) free_FIX_StreamAsgnRptID;
  SwigClassStreamAsgnRptID.trackObjects = 0;
  
  SwigClassOrderDelayUnit.klass = rb_define_class_under(mQuickfix, "OrderDelayUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderDelayUnit, (void *) &SwigClassOrderDelayUnit);
  rb_define_alloc_func(SwigClassOrderDelayUnit.klass, _wrap_OrderDelayUnit_allocate);
  rb_define_method(SwigClassOrderDelayUnit.klass, "initialize", VALUEFUNC(_wrap_new_OrderDelayUnit), -1);
  SwigClassOrderDelayUnit.mark = 0;
  SwigClassOrderDelayUnit.destroy = (void (*)(void *)) free_FIX_OrderDelayUnit;
  SwigClassOrderDelayUnit.trackObjects = 0;
  
  SwigClassLegCurrencyRatio.klass = rb_define_class_under(mQuickfix, "LegCurrencyRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCurrencyRatio, (void *) &SwigClassLegCurrencyRatio);
  rb_define_alloc_func(SwigClassLegCurrencyRatio.klass, _wrap_LegCurrencyRatio_allocate);
  rb_define_method(SwigClassLegCurrencyRatio.klass, "initialize", VALUEFUNC(_wrap_new_LegCurrencyRatio), -1);
  SwigClassLegCurrencyRatio.mark = 0;
  SwigClassLegCurrencyRatio.destroy = (void (*)(void *)) free_FIX_LegCurrencyRatio;
  SwigClassLegCurrencyRatio.trackObjects = 0;
  
  SwigClassEndTickPriceRange.klass = rb_define_class_under(mQuickfix, "EndTickPriceRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndTickPriceRange, (void *) &SwigClassEndTickPriceRange);
  rb_define_alloc_func(SwigClassEndTickPriceRange.klass, _wrap_EndTickPriceRange_allocate);
  rb_define_method(SwigClassEndTickPriceRange.klass, "initialize", VALUEFUNC(_wrap_new_EndTickPriceRange), -1);
  SwigClassEndTickPriceRange.mark = 0;
  SwigClassEndTickPriceRange.destroy = (void (*)(void *)) free_FIX_EndTickPriceRange;
  SwigClassEndTickPriceRange.trackObjects = 0;
  
  SwigClassCollReqID.klass = rb_define_class_under(mQuickfix, "CollReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollReqID, (void *) &SwigClassCollReqID);
  rb_define_alloc_func(SwigClassCollReqID.klass, _wrap_CollReqID_allocate);
  rb_define_method(SwigClassCollReqID.klass, "initialize", VALUEFUNC(_wrap_new_CollReqID), -1);
  SwigClassCollReqID.mark = 0;
  SwigClassCollReqID.destroy = (void (*)(void *)) free_FIX_CollReqID;
  SwigClassCollReqID.trackObjects = 0;
  
  SwigClassLegPool.klass = rb_define_class_under(mQuickfix, "LegPool", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPool, (void *) &SwigClassLegPool);
  rb_define_alloc_func(SwigClassLegPool.klass, _wrap_LegPool_allocate);
  rb_define_method(SwigClassLegPool.klass, "initialize", VALUEFUNC(_wrap_new_LegPool), -1);
  SwigClassLegPool.mark = 0;
  SwigClassLegPool.destroy = (void (*)(void *)) free_FIX_LegPool;
  SwigClassLegPool.trackObjects = 0;
  
  SwigClassShortQty.klass = rb_define_class_under(mQuickfix, "ShortQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ShortQty, (void *) &SwigClassShortQty);
  rb_define_alloc_func(SwigClassShortQty.klass, _wrap_ShortQty_allocate);
  rb_define_method(SwigClassShortQty.klass, "initialize", VALUEFUNC(_wrap_new_ShortQty), -1);
  SwigClassShortQty.mark = 0;
  SwigClassShortQty.destroy = (void (*)(void *)) free_FIX_ShortQty;
  SwigClassShortQty.trackObjects = 0;
  
  SwigClassSideValue2.klass = rb_define_class_under(mQuickfix, "SideValue2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideValue2, (void *) &SwigClassSideValue2);
  rb_define_alloc_func(SwigClassSideValue2.klass, _wrap_SideValue2_allocate);
  rb_define_method(SwigClassSideValue2.klass, "initialize", VALUEFUNC(_wrap_new_SideValue2), -1);
  SwigClassSideValue2.mark = 0;
  SwigClassSideValue2.destroy = (void (*)(void *)) free_FIX_SideValue2;
  SwigClassSideValue2.trackObjects = 0;
  
  SwigClassTradedFlatSwitch.klass = rb_define_class_under(mQuickfix, "TradedFlatSwitch", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradedFlatSwitch, (void *) &SwigClassTradedFlatSwitch);
  rb_define_alloc_func(SwigClassTradedFlatSwitch.klass, _wrap_TradedFlatSwitch_allocate);
  rb_define_method(SwigClassTradedFlatSwitch.klass, "initialize", VALUEFUNC(_wrap_new_TradedFlatSwitch), -1);
  SwigClassTradedFlatSwitch.mark = 0;
  SwigClassTradedFlatSwitch.destroy = (void (*)(void *)) free_FIX_TradedFlatSwitch;
  SwigClassTradedFlatSwitch.trackObjects = 0;
  
  SwigClassMassStatusReqID.klass = rb_define_class_under(mQuickfix, "MassStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassStatusReqID, (void *) &SwigClassMassStatusReqID);
  rb_define_alloc_func(SwigClassMassStatusReqID.klass, _wrap_MassStatusReqID_allocate);
  rb_define_method(SwigClassMassStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_MassStatusReqID), -1);
  SwigClassMassStatusReqID.mark = 0;
  SwigClassMassStatusReqID.destroy = (void (*)(void *)) free_FIX_MassStatusReqID;
  SwigClassMassStatusReqID.trackObjects = 0;
  
  SwigClassComplexEventEndDate.klass = rb_define_class_under(mQuickfix, "ComplexEventEndDate", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventEndDate, (void *) &SwigClassComplexEventEndDate);
  rb_define_alloc_func(SwigClassComplexEventEndDate.klass, _wrap_ComplexEventEndDate_allocate);
  rb_define_method(SwigClassComplexEventEndDate.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventEndDate), -1);
  SwigClassComplexEventEndDate.mark = 0;
  SwigClassComplexEventEndDate.destroy = (void (*)(void *)) free_FIX_ComplexEventEndDate;
  SwigClassComplexEventEndDate.trackObjects = 0;
  
  SwigClassMarketID.klass = rb_define_class_under(mQuickfix, "MarketID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketID, (void *) &SwigClassMarketID);
  rb_define_alloc_func(SwigClassMarketID.klass, _wrap_MarketID_allocate);
  rb_define_method(SwigClassMarketID.klass, "initialize", VALUEFUNC(_wrap_new_MarketID), -1);
  SwigClassMarketID.mark = 0;
  SwigClassMarketID.destroy = (void (*)(void *)) free_FIX_MarketID;
  SwigClassMarketID.trackObjects = 0;
  
  SwigClassOrigTradeDate.klass = rb_define_class_under(mQuickfix, "OrigTradeDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTradeDate, (void *) &SwigClassOrigTradeDate);
  rb_define_alloc_func(SwigClassOrigTradeDate.klass, _wrap_OrigTradeDate_allocate);
  rb_define_method(SwigClassOrigTradeDate.klass, "initialize", VALUEFUNC(_wrap_new_OrigTradeDate), -1);
  SwigClassOrigTradeDate.mark = 0;
  SwigClassOrigTradeDate.destroy = (void (*)(void *)) free_FIX_OrigTradeDate;
  SwigClassOrigTradeDate.trackObjects = 0;
  
  SwigClassPreTradeAnonymity.klass = rb_define_class_under(mQuickfix, "PreTradeAnonymity", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PreTradeAnonymity, (void *) &SwigClassPreTradeAnonymity);
  rb_define_alloc_func(SwigClassPreTradeAnonymity.klass, _wrap_PreTradeAnonymity_allocate);
  rb_define_method(SwigClassPreTradeAnonymity.klass, "initialize", VALUEFUNC(_wrap_new_PreTradeAnonymity), -1);
  SwigClassPreTradeAnonymity.mark = 0;
  SwigClassPreTradeAnonymity.destroy = (void (*)(void *)) free_FIX_PreTradeAnonymity;
  SwigClassPreTradeAnonymity.trackObjects = 0;
  
  SwigClassTrdRptStatus.klass = rb_define_class_under(mQuickfix, "TrdRptStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRptStatus, (void *) &SwigClassTrdRptStatus);
  rb_define_alloc_func(SwigClassTrdRptStatus.klass, _wrap_TrdRptStatus_allocate);
  rb_define_method(SwigClassTrdRptStatus.klass, "initialize", VALUEFUNC(_wrap_new_TrdRptStatus), -1);
  SwigClassTrdRptStatus.mark = 0;
  SwigClassTrdRptStatus.destroy = (void (*)(void *)) free_FIX_TrdRptStatus;
  SwigClassTrdRptStatus.trackObjects = 0;
  
  SwigClassDistribPercentage.klass = rb_define_class_under(mQuickfix, "DistribPercentage", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DistribPercentage, (void *) &SwigClassDistribPercentage);
  rb_define_alloc_func(SwigClassDistribPercentage.klass, _wrap_DistribPercentage_allocate);
  rb_define_method(SwigClassDistribPercentage.klass, "initialize", VALUEFUNC(_wrap_new_DistribPercentage), -1);
  SwigClassDistribPercentage.mark = 0;
  SwigClassDistribPercentage.destroy = (void (*)(void *)) free_FIX_DistribPercentage;
  SwigClassDistribPercentage.trackObjects = 0;
  
  SwigClassQuoteStatus.klass = rb_define_class_under(mQuickfix, "QuoteStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteStatus, (void *) &SwigClassQuoteStatus);
  rb_define_alloc_func(SwigClassQuoteStatus.klass, _wrap_QuoteStatus_allocate);
  rb_define_method(SwigClassQuoteStatus.klass, "initialize", VALUEFUNC(_wrap_new_QuoteStatus), -1);
  SwigClassQuoteStatus.mark = 0;
  SwigClassQuoteStatus.destroy = (void (*)(void *)) free_FIX_QuoteStatus;
  SwigClassQuoteStatus.trackObjects = 0;
  
  SwigClassClearingAccount.klass = rb_define_class_under(mQuickfix, "ClearingAccount", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingAccount, (void *) &SwigClassClearingAccount);
  rb_define_alloc_func(SwigClassClearingAccount.klass, _wrap_ClearingAccount_allocate);
  rb_define_method(SwigClassClearingAccount.klass, "initialize", VALUEFUNC(_wrap_new_ClearingAccount), -1);
  SwigClassClearingAccount.mark = 0;
  SwigClassClearingAccount.destroy = (void (*)(void *)) free_FIX_ClearingAccount;
  SwigClassClearingAccount.trackObjects = 0;
  
  SwigClassTrdMatchID.klass = rb_define_class_under(mQuickfix, "TrdMatchID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdMatchID, (void *) &SwigClassTrdMatchID);
  rb_define_alloc_func(SwigClassTrdMatchID.klass, _wrap_TrdMatchID_allocate);
  rb_define_method(SwigClassTrdMatchID.klass, "initialize", VALUEFUNC(_wrap_new_TrdMatchID), -1);
  SwigClassTrdMatchID.mark = 0;
  SwigClassTrdMatchID.destroy = (void (*)(void *)) free_FIX_TrdMatchID;
  SwigClassTrdMatchID.trackObjects = 0;
  
  SwigClassOrderInputDevice.klass = rb_define_class_under(mQuickfix, "OrderInputDevice", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderInputDevice, (void *) &SwigClassOrderInputDevice);
  rb_define_alloc_func(SwigClassOrderInputDevice.klass, _wrap_OrderInputDevice_allocate);
  rb_define_method(SwigClassOrderInputDevice.klass, "initialize", VALUEFUNC(_wrap_new_OrderInputDevice), -1);
  SwigClassOrderInputDevice.mark = 0;
  SwigClassOrderInputDevice.destroy = (void (*)(void *)) free_FIX_OrderInputDevice;
  SwigClassOrderInputDevice.trackObjects = 0;
  
  SwigClassSolicitedFlag.klass = rb_define_class_under(mQuickfix, "SolicitedFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SolicitedFlag, (void *) &SwigClassSolicitedFlag);
  rb_define_alloc_func(SwigClassSolicitedFlag.klass, _wrap_SolicitedFlag_allocate);
  rb_define_method(SwigClassSolicitedFlag.klass, "initialize", VALUEFUNC(_wrap_new_SolicitedFlag), -1);
  SwigClassSolicitedFlag.mark = 0;
  SwigClassSolicitedFlag.destroy = (void (*)(void *)) free_FIX_SolicitedFlag;
  SwigClassSolicitedFlag.trackObjects = 0;
  
  SwigClassTransactTime.klass = rb_define_class_under(mQuickfix, "TransactTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TransactTime, (void *) &SwigClassTransactTime);
  rb_define_alloc_func(SwigClassTransactTime.klass, _wrap_TransactTime_allocate);
  rb_define_method(SwigClassTransactTime.klass, "initialize", VALUEFUNC(_wrap_new_TransactTime), -1);
  SwigClassTransactTime.mark = 0;
  SwigClassTransactTime.destroy = (void (*)(void *)) free_FIX_TransactTime;
  SwigClassTransactTime.trackObjects = 0;
  
  SwigClassUnderlyingFlowScheduleType.klass = rb_define_class_under(mQuickfix, "UnderlyingFlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFlowScheduleType, (void *) &SwigClassUnderlyingFlowScheduleType);
  rb_define_alloc_func(SwigClassUnderlyingFlowScheduleType.klass, _wrap_UnderlyingFlowScheduleType_allocate);
  rb_define_method(SwigClassUnderlyingFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFlowScheduleType), -1);
  SwigClassUnderlyingFlowScheduleType.mark = 0;
  SwigClassUnderlyingFlowScheduleType.destroy = (void (*)(void *)) free_FIX_UnderlyingFlowScheduleType;
  SwigClassUnderlyingFlowScheduleType.trackObjects = 0;
  
  SwigClassUnderlyingStipValue.klass = rb_define_class_under(mQuickfix, "UnderlyingStipValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStipValue, (void *) &SwigClassUnderlyingStipValue);
  rb_define_alloc_func(SwigClassUnderlyingStipValue.klass, _wrap_UnderlyingStipValue_allocate);
  rb_define_method(SwigClassUnderlyingStipValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStipValue), -1);
  SwigClassUnderlyingStipValue.mark = 0;
  SwigClassUnderlyingStipValue.destroy = (void (*)(void *)) free_FIX_UnderlyingStipValue;
  SwigClassUnderlyingStipValue.trackObjects = 0;
  
  SwigClassNextExpectedMsgSeqNum.klass = rb_define_class_under(mQuickfix, "NextExpectedMsgSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NextExpectedMsgSeqNum, (void *) &SwigClassNextExpectedMsgSeqNum);
  rb_define_alloc_func(SwigClassNextExpectedMsgSeqNum.klass, _wrap_NextExpectedMsgSeqNum_allocate);
  rb_define_method(SwigClassNextExpectedMsgSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_NextExpectedMsgSeqNum), -1);
  SwigClassNextExpectedMsgSeqNum.mark = 0;
  SwigClassNextExpectedMsgSeqNum.destroy = (void (*)(void *)) free_FIX_NextExpectedMsgSeqNum;
  SwigClassNextExpectedMsgSeqNum.trackObjects = 0;
  
  SwigClassBenchmarkCurveCurrency.klass = rb_define_class_under(mQuickfix, "BenchmarkCurveCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkCurveCurrency, (void *) &SwigClassBenchmarkCurveCurrency);
  rb_define_alloc_func(SwigClassBenchmarkCurveCurrency.klass, _wrap_BenchmarkCurveCurrency_allocate);
  rb_define_method(SwigClassBenchmarkCurveCurrency.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkCurveCurrency), -1);
  SwigClassBenchmarkCurveCurrency.mark = 0;
  SwigClassBenchmarkCurveCurrency.destroy = (void (*)(void *)) free_FIX_BenchmarkCurveCurrency;
  SwigClassBenchmarkCurveCurrency.trackObjects = 0;
  
  SwigClassCFICode.klass = rb_define_class_under(mQuickfix, "CFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CFICode, (void *) &SwigClassCFICode);
  rb_define_alloc_func(SwigClassCFICode.klass, _wrap_CFICode_allocate);
  rb_define_method(SwigClassCFICode.klass, "initialize", VALUEFUNC(_wrap_new_CFICode), -1);
  SwigClassCFICode.mark = 0;
  SwigClassCFICode.destroy = (void (*)(void *)) free_FIX_CFICode;
  SwigClassCFICode.trackObjects = 0;
  
  SwigClassFactor.klass = rb_define_class_under(mQuickfix, "Factor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Factor, (void *) &SwigClassFactor);
  rb_define_alloc_func(SwigClassFactor.klass, _wrap_Factor_allocate);
  rb_define_method(SwigClassFactor.klass, "initialize", VALUEFUNC(_wrap_new_Factor), -1);
  SwigClassFactor.mark = 0;
  SwigClassFactor.destroy = (void (*)(void *)) free_FIX_Factor;
  SwigClassFactor.trackObjects = 0;
  
  SwigClassLastShares.klass = rb_define_class_under(mQuickfix, "LastShares", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastShares, (void *) &SwigClassLastShares);
  rb_define_alloc_func(SwigClassLastShares.klass, _wrap_LastShares_allocate);
  rb_define_method(SwigClassLastShares.klass, "initialize", VALUEFUNC(_wrap_new_LastShares), -1);
  SwigClassLastShares.mark = 0;
  SwigClassLastShares.destroy = (void (*)(void *)) free_FIX_LastShares;
  SwigClassLastShares.trackObjects = 0;
  
  SwigClassEventTime.klass = rb_define_class_under(mQuickfix, "EventTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventTime, (void *) &SwigClassEventTime);
  rb_define_alloc_func(SwigClassEventTime.klass, _wrap_EventTime_allocate);
  rb_define_method(SwigClassEventTime.klass, "initialize", VALUEFUNC(_wrap_new_EventTime), -1);
  SwigClassEventTime.mark = 0;
  SwigClassEventTime.destroy = (void (*)(void *)) free_FIX_EventTime;
  SwigClassEventTime.trackObjects = 0;
  
  SwigClassRootPartySubIDType.klass = rb_define_class_under(mQuickfix, "RootPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartySubIDType, (void *) &SwigClassRootPartySubIDType);
  rb_define_alloc_func(SwigClassRootPartySubIDType.klass, _wrap_RootPartySubIDType_allocate);
  rb_define_method(SwigClassRootPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_RootPartySubIDType), -1);
  SwigClassRootPartySubIDType.mark = 0;
  SwigClassRootPartySubIDType.destroy = (void (*)(void *)) free_FIX_RootPartySubIDType;
  SwigClassRootPartySubIDType.trackObjects = 0;
  
  SwigClassShortSaleReason.klass = rb_define_class_under(mQuickfix, "ShortSaleReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ShortSaleReason, (void *) &SwigClassShortSaleReason);
  rb_define_alloc_func(SwigClassShortSaleReason.klass, _wrap_ShortSaleReason_allocate);
  rb_define_method(SwigClassShortSaleReason.klass, "initialize", VALUEFUNC(_wrap_new_ShortSaleReason), -1);
  SwigClassShortSaleReason.mark = 0;
  SwigClassShortSaleReason.destroy = (void (*)(void *)) free_FIX_ShortSaleReason;
  SwigClassShortSaleReason.trackObjects = 0;
  
  SwigClassXmlData.klass = rb_define_class_under(mQuickfix, "XmlData", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__XmlData, (void *) &SwigClassXmlData);
  rb_define_alloc_func(SwigClassXmlData.klass, _wrap_XmlData_allocate);
  rb_define_method(SwigClassXmlData.klass, "initialize", VALUEFUNC(_wrap_new_XmlData), -1);
  SwigClassXmlData.mark = 0;
  SwigClassXmlData.destroy = (void (*)(void *)) free_FIX_XmlData;
  SwigClassXmlData.trackObjects = 0;
  
  SwigClassNoTargetPartyIDs.klass = rb_define_class_under(mQuickfix, "NoTargetPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTargetPartyIDs, (void *) &SwigClassNoTargetPartyIDs);
  rb_define_alloc_func(SwigClassNoTargetPartyIDs.klass, _wrap_NoTargetPartyIDs_allocate);
  rb_define_method(SwigClassNoTargetPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoTargetPartyIDs), -1);
  SwigClassNoTargetPartyIDs.mark = 0;
  SwigClassNoTargetPartyIDs.destroy = (void (*)(void *)) free_FIX_NoTargetPartyIDs;
  SwigClassNoTargetPartyIDs.trackObjects = 0;
  
  SwigClassNoRootPartyIDs.klass = rb_define_class_under(mQuickfix, "NoRootPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRootPartyIDs, (void *) &SwigClassNoRootPartyIDs);
  rb_define_alloc_func(SwigClassNoRootPartyIDs.klass, _wrap_NoRootPartyIDs_allocate);
  rb_define_method(SwigClassNoRootPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRootPartyIDs), -1);
  SwigClassNoRootPartyIDs.mark = 0;
  SwigClassNoRootPartyIDs.destroy = (void (*)(void *)) free_FIX_NoRootPartyIDs;
  SwigClassNoRootPartyIDs.trackObjects = 0;
  
  SwigClassEventDate.klass = rb_define_class_under(mQuickfix, "EventDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventDate, (void *) &SwigClassEventDate);
  rb_define_alloc_func(SwigClassEventDate.klass, _wrap_EventDate_allocate);
  rb_define_method(SwigClassEventDate.klass, "initialize", VALUEFUNC(_wrap_new_EventDate), -1);
  SwigClassEventDate.mark = 0;
  SwigClassEventDate.destroy = (void (*)(void *)) free_FIX_EventDate;
  SwigClassEventDate.trackObjects = 0;
  
  SwigClassPegRoundDirection.klass = rb_define_class_under(mQuickfix, "PegRoundDirection", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegRoundDirection, (void *) &SwigClassPegRoundDirection);
  rb_define_alloc_func(SwigClassPegRoundDirection.klass, _wrap_PegRoundDirection_allocate);
  rb_define_method(SwigClassPegRoundDirection.klass, "initialize", VALUEFUNC(_wrap_new_PegRoundDirection), -1);
  SwigClassPegRoundDirection.mark = 0;
  SwigClassPegRoundDirection.destroy = (void (*)(void *)) free_FIX_PegRoundDirection;
  SwigClassPegRoundDirection.trackObjects = 0;
  
  SwigClassLegSettlDate.klass = rb_define_class_under(mQuickfix, "LegSettlDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlDate, (void *) &SwigClassLegSettlDate);
  rb_define_alloc_func(SwigClassLegSettlDate.klass, _wrap_LegSettlDate_allocate);
  rb_define_method(SwigClassLegSettlDate.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlDate), -1);
  SwigClassLegSettlDate.mark = 0;
  SwigClassLegSettlDate.destroy = (void (*)(void *)) free_FIX_LegSettlDate;
  SwigClassLegSettlDate.trackObjects = 0;
  
  SwigClassModelType.klass = rb_define_class_under(mQuickfix, "ModelType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ModelType, (void *) &SwigClassModelType);
  rb_define_alloc_func(SwigClassModelType.klass, _wrap_ModelType_allocate);
  rb_define_method(SwigClassModelType.klass, "initialize", VALUEFUNC(_wrap_new_ModelType), -1);
  SwigClassModelType.mark = 0;
  SwigClassModelType.destroy = (void (*)(void *)) free_FIX_ModelType;
  SwigClassModelType.trackObjects = 0;
  
  SwigClassDefaultVerIndicator.klass = rb_define_class_under(mQuickfix, "DefaultVerIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultVerIndicator, (void *) &SwigClassDefaultVerIndicator);
  rb_define_alloc_func(SwigClassDefaultVerIndicator.klass, _wrap_DefaultVerIndicator_allocate);
  rb_define_method(SwigClassDefaultVerIndicator.klass, "initialize", VALUEFUNC(_wrap_new_DefaultVerIndicator), -1);
  SwigClassDefaultVerIndicator.mark = 0;
  SwigClassDefaultVerIndicator.destroy = (void (*)(void *)) free_FIX_DefaultVerIndicator;
  SwigClassDefaultVerIndicator.trackObjects = 0;
  
  SwigClassFuturesValuationMethod.klass = rb_define_class_under(mQuickfix, "FuturesValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FuturesValuationMethod, (void *) &SwigClassFuturesValuationMethod);
  rb_define_alloc_func(SwigClassFuturesValuationMethod.klass, _wrap_FuturesValuationMethod_allocate);
  rb_define_method(SwigClassFuturesValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_FuturesValuationMethod), -1);
  SwigClassFuturesValuationMethod.mark = 0;
  SwigClassFuturesValuationMethod.destroy = (void (*)(void *)) free_FIX_FuturesValuationMethod;
  SwigClassFuturesValuationMethod.trackObjects = 0;
  
  SwigClassSettlMethod.klass = rb_define_class_under(mQuickfix, "SettlMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlMethod, (void *) &SwigClassSettlMethod);
  rb_define_alloc_func(SwigClassSettlMethod.klass, _wrap_SettlMethod_allocate);
  rb_define_method(SwigClassSettlMethod.klass, "initialize", VALUEFUNC(_wrap_new_SettlMethod), -1);
  SwigClassSettlMethod.mark = 0;
  SwigClassSettlMethod.destroy = (void (*)(void *)) free_FIX_SettlMethod;
  SwigClassSettlMethod.trackObjects = 0;
  
  SwigClassUnderlyingFXRate.klass = rb_define_class_under(mQuickfix, "UnderlyingFXRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFXRate, (void *) &SwigClassUnderlyingFXRate);
  rb_define_alloc_func(SwigClassUnderlyingFXRate.klass, _wrap_UnderlyingFXRate_allocate);
  rb_define_method(SwigClassUnderlyingFXRate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFXRate), -1);
  SwigClassUnderlyingFXRate.mark = 0;
  SwigClassUnderlyingFXRate.destroy = (void (*)(void *)) free_FIX_UnderlyingFXRate;
  SwigClassUnderlyingFXRate.trackObjects = 0;
  
  SwigClassConfirmStatus.klass = rb_define_class_under(mQuickfix, "ConfirmStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmStatus, (void *) &SwigClassConfirmStatus);
  rb_define_alloc_func(SwigClassConfirmStatus.klass, _wrap_ConfirmStatus_allocate);
  rb_define_method(SwigClassConfirmStatus.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmStatus), -1);
  SwigClassConfirmStatus.mark = 0;
  SwigClassConfirmStatus.destroy = (void (*)(void *)) free_FIX_ConfirmStatus;
  SwigClassConfirmStatus.trackObjects = 0;
  
  SwigClassLocateReqd.klass = rb_define_class_under(mQuickfix, "LocateReqd", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LocateReqd, (void *) &SwigClassLocateReqd);
  rb_define_alloc_func(SwigClassLocateReqd.klass, _wrap_LocateReqd_allocate);
  rb_define_method(SwigClassLocateReqd.klass, "initialize", VALUEFUNC(_wrap_new_LocateReqd), -1);
  SwigClassLocateReqd.mark = 0;
  SwigClassLocateReqd.destroy = (void (*)(void *)) free_FIX_LocateReqd;
  SwigClassLocateReqd.trackObjects = 0;
  
  SwigClassPosMaintRptID.klass = rb_define_class_under(mQuickfix, "PosMaintRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintRptID, (void *) &SwigClassPosMaintRptID);
  rb_define_alloc_func(SwigClassPosMaintRptID.klass, _wrap_PosMaintRptID_allocate);
  rb_define_method(SwigClassPosMaintRptID.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintRptID), -1);
  SwigClassPosMaintRptID.mark = 0;
  SwigClassPosMaintRptID.destroy = (void (*)(void *)) free_FIX_PosMaintRptID;
  SwigClassPosMaintRptID.trackObjects = 0;
  
  SwigClassAdjustment.klass = rb_define_class_under(mQuickfix, "Adjustment", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Adjustment, (void *) &SwigClassAdjustment);
  rb_define_alloc_func(SwigClassAdjustment.klass, _wrap_Adjustment_allocate);
  rb_define_method(SwigClassAdjustment.klass, "initialize", VALUEFUNC(_wrap_new_Adjustment), -1);
  SwigClassAdjustment.mark = 0;
  SwigClassAdjustment.destroy = (void (*)(void *)) free_FIX_Adjustment;
  SwigClassAdjustment.trackObjects = 0;
  
  SwigClassStreamAsgnType.klass = rb_define_class_under(mQuickfix, "StreamAsgnType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnType, (void *) &SwigClassStreamAsgnType);
  rb_define_alloc_func(SwigClassStreamAsgnType.klass, _wrap_StreamAsgnType_allocate);
  rb_define_method(SwigClassStreamAsgnType.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnType), -1);
  SwigClassStreamAsgnType.mark = 0;
  SwigClassStreamAsgnType.destroy = (void (*)(void *)) free_FIX_StreamAsgnType;
  SwigClassStreamAsgnType.trackObjects = 0;
  
  SwigClassLastRptRequested.klass = rb_define_class_under(mQuickfix, "LastRptRequested", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastRptRequested, (void *) &SwigClassLastRptRequested);
  rb_define_alloc_func(SwigClassLastRptRequested.klass, _wrap_LastRptRequested_allocate);
  rb_define_method(SwigClassLastRptRequested.klass, "initialize", VALUEFUNC(_wrap_new_LastRptRequested), -1);
  SwigClassLastRptRequested.mark = 0;
  SwigClassLastRptRequested.destroy = (void (*)(void *)) free_FIX_LastRptRequested;
  SwigClassLastRptRequested.trackObjects = 0;
  
  SwigClassLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "LocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LocaleOfIssue, (void *) &SwigClassLocaleOfIssue);
  rb_define_alloc_func(SwigClassLocaleOfIssue.klass, _wrap_LocaleOfIssue_allocate);
  rb_define_method(SwigClassLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LocaleOfIssue), -1);
  SwigClassLocaleOfIssue.mark = 0;
  SwigClassLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_LocaleOfIssue;
  SwigClassLocaleOfIssue.trackObjects = 0;
  
  SwigClassSenderSubID.klass = rb_define_class_under(mQuickfix, "SenderSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SenderSubID, (void *) &SwigClassSenderSubID);
  rb_define_alloc_func(SwigClassSenderSubID.klass, _wrap_SenderSubID_allocate);
  rb_define_method(SwigClassSenderSubID.klass, "initialize", VALUEFUNC(_wrap_new_SenderSubID), -1);
  SwigClassSenderSubID.mark = 0;
  SwigClassSenderSubID.destroy = (void (*)(void *)) free_FIX_SenderSubID;
  SwigClassSenderSubID.trackObjects = 0;
  
  SwigClassHighPx.klass = rb_define_class_under(mQuickfix, "HighPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HighPx, (void *) &SwigClassHighPx);
  rb_define_alloc_func(SwigClassHighPx.klass, _wrap_HighPx_allocate);
  rb_define_method(SwigClassHighPx.klass, "initialize", VALUEFUNC(_wrap_new_HighPx), -1);
  SwigClassHighPx.mark = 0;
  SwigClassHighPx.destroy = (void (*)(void *)) free_FIX_HighPx;
  SwigClassHighPx.trackObjects = 0;
  
  SwigClassAllocSettlCurrAmt.klass = rb_define_class_under(mQuickfix, "AllocSettlCurrAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocSettlCurrAmt, (void *) &SwigClassAllocSettlCurrAmt);
  rb_define_alloc_func(SwigClassAllocSettlCurrAmt.klass, _wrap_AllocSettlCurrAmt_allocate);
  rb_define_method(SwigClassAllocSettlCurrAmt.klass, "initialize", VALUEFUNC(_wrap_new_AllocSettlCurrAmt), -1);
  SwigClassAllocSettlCurrAmt.mark = 0;
  SwigClassAllocSettlCurrAmt.destroy = (void (*)(void *)) free_FIX_AllocSettlCurrAmt;
  SwigClassAllocSettlCurrAmt.trackObjects = 0;
  
  SwigClassComplexEventPriceBoundaryPrecision.klass = rb_define_class_under(mQuickfix, "ComplexEventPriceBoundaryPrecision", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision, (void *) &SwigClassComplexEventPriceBoundaryPrecision);
  rb_define_alloc_func(SwigClassComplexEventPriceBoundaryPrecision.klass, _wrap_ComplexEventPriceBoundaryPrecision_allocate);
  rb_define_method(SwigClassComplexEventPriceBoundaryPrecision.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPriceBoundaryPrecision), -1);
  SwigClassComplexEventPriceBoundaryPrecision.mark = 0;
  SwigClassComplexEventPriceBoundaryPrecision.destroy = (void (*)(void *)) free_FIX_ComplexEventPriceBoundaryPrecision;
  SwigClassComplexEventPriceBoundaryPrecision.trackObjects = 0;
  
  SwigClassInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "InstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartyRole, (void *) &SwigClassInstrumentPartyRole);
  rb_define_alloc_func(SwigClassInstrumentPartyRole.klass, _wrap_InstrumentPartyRole_allocate);
  rb_define_method(SwigClassInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartyRole), -1);
  SwigClassInstrumentPartyRole.mark = 0;
  SwigClassInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_InstrumentPartyRole;
  SwigClassInstrumentPartyRole.trackObjects = 0;
  
  SwigClassYieldRedemptionPrice.klass = rb_define_class_under(mQuickfix, "YieldRedemptionPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldRedemptionPrice, (void *) &SwigClassYieldRedemptionPrice);
  rb_define_alloc_func(SwigClassYieldRedemptionPrice.klass, _wrap_YieldRedemptionPrice_allocate);
  rb_define_method(SwigClassYieldRedemptionPrice.klass, "initialize", VALUEFUNC(_wrap_new_YieldRedemptionPrice), -1);
  SwigClassYieldRedemptionPrice.mark = 0;
  SwigClassYieldRedemptionPrice.destroy = (void (*)(void *)) free_FIX_YieldRedemptionPrice;
  SwigClassYieldRedemptionPrice.trackObjects = 0;
  
  SwigClassCumQty.klass = rb_define_class_under(mQuickfix, "CumQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CumQty, (void *) &SwigClassCumQty);
  rb_define_alloc_func(SwigClassCumQty.klass, _wrap_CumQty_allocate);
  rb_define_method(SwigClassCumQty.klass, "initialize", VALUEFUNC(_wrap_new_CumQty), -1);
  SwigClassCumQty.mark = 0;
  SwigClassCumQty.destroy = (void (*)(void *)) free_FIX_CumQty;
  SwigClassCumQty.trackObjects = 0;
  
  SwigClassOrigClOrdID.klass = rb_define_class_under(mQuickfix, "OrigClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigClOrdID, (void *) &SwigClassOrigClOrdID);
  rb_define_alloc_func(SwigClassOrigClOrdID.klass, _wrap_OrigClOrdID_allocate);
  rb_define_method(SwigClassOrigClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_OrigClOrdID), -1);
  SwigClassOrigClOrdID.mark = 0;
  SwigClassOrigClOrdID.destroy = (void (*)(void *)) free_FIX_OrigClOrdID;
  SwigClassOrigClOrdID.trackObjects = 0;
  
  SwigClassSettlSessID.klass = rb_define_class_under(mQuickfix, "SettlSessID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlSessID, (void *) &SwigClassSettlSessID);
  rb_define_alloc_func(SwigClassSettlSessID.klass, _wrap_SettlSessID_allocate);
  rb_define_method(SwigClassSettlSessID.klass, "initialize", VALUEFUNC(_wrap_new_SettlSessID), -1);
  SwigClassSettlSessID.mark = 0;
  SwigClassSettlSessID.destroy = (void (*)(void *)) free_FIX_SettlSessID;
  SwigClassSettlSessID.trackObjects = 0;
  
  SwigClassParentMktSegmID.klass = rb_define_class_under(mQuickfix, "ParentMktSegmID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ParentMktSegmID, (void *) &SwigClassParentMktSegmID);
  rb_define_alloc_func(SwigClassParentMktSegmID.klass, _wrap_ParentMktSegmID_allocate);
  rb_define_method(SwigClassParentMktSegmID.klass, "initialize", VALUEFUNC(_wrap_new_ParentMktSegmID), -1);
  SwigClassParentMktSegmID.mark = 0;
  SwigClassParentMktSegmID.destroy = (void (*)(void *)) free_FIX_ParentMktSegmID;
  SwigClassParentMktSegmID.trackObjects = 0;
  
  SwigClassTradeReportType.klass = rb_define_class_under(mQuickfix, "TradeReportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportType, (void *) &SwigClassTradeReportType);
  rb_define_alloc_func(SwigClassTradeReportType.klass, _wrap_TradeReportType_allocate);
  rb_define_method(SwigClassTradeReportType.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportType), -1);
  SwigClassTradeReportType.mark = 0;
  SwigClassTradeReportType.destroy = (void (*)(void *)) free_FIX_TradeReportType;
  SwigClassTradeReportType.trackObjects = 0;
  
  SwigClassAvgPrxPrecision.klass = rb_define_class_under(mQuickfix, "AvgPrxPrecision", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPrxPrecision, (void *) &SwigClassAvgPrxPrecision);
  rb_define_alloc_func(SwigClassAvgPrxPrecision.klass, _wrap_AvgPrxPrecision_allocate);
  rb_define_method(SwigClassAvgPrxPrecision.klass, "initialize", VALUEFUNC(_wrap_new_AvgPrxPrecision), -1);
  SwigClassAvgPrxPrecision.mark = 0;
  SwigClassAvgPrxPrecision.destroy = (void (*)(void *)) free_FIX_AvgPrxPrecision;
  SwigClassAvgPrxPrecision.trackObjects = 0;
  
  SwigClassNoLegs.klass = rb_define_class_under(mQuickfix, "NoLegs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegs, (void *) &SwigClassNoLegs);
  rb_define_alloc_func(SwigClassNoLegs.klass, _wrap_NoLegs_allocate);
  rb_define_method(SwigClassNoLegs.klass, "initialize", VALUEFUNC(_wrap_new_NoLegs), -1);
  SwigClassNoLegs.mark = 0;
  SwigClassNoLegs.destroy = (void (*)(void *)) free_FIX_NoLegs;
  SwigClassNoLegs.trackObjects = 0;
  
  SwigClassUnderlyingSymbol.klass = rb_define_class_under(mQuickfix, "UnderlyingSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSymbol, (void *) &SwigClassUnderlyingSymbol);
  rb_define_alloc_func(SwigClassUnderlyingSymbol.klass, _wrap_UnderlyingSymbol_allocate);
  rb_define_method(SwigClassUnderlyingSymbol.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSymbol), -1);
  SwigClassUnderlyingSymbol.mark = 0;
  SwigClassUnderlyingSymbol.destroy = (void (*)(void *)) free_FIX_UnderlyingSymbol;
  SwigClassUnderlyingSymbol.trackObjects = 0;
  
  SwigClassExerciseStyle.klass = rb_define_class_under(mQuickfix, "ExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExerciseStyle, (void *) &SwigClassExerciseStyle);
  rb_define_alloc_func(SwigClassExerciseStyle.klass, _wrap_ExerciseStyle_allocate);
  rb_define_method(SwigClassExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_ExerciseStyle), -1);
  SwigClassExerciseStyle.mark = 0;
  SwigClassExerciseStyle.destroy = (void (*)(void *)) free_FIX_ExerciseStyle;
  SwigClassExerciseStyle.trackObjects = 0;
  
  SwigClassHaltReasonChar.klass = rb_define_class_under(mQuickfix, "HaltReasonChar", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HaltReasonChar, (void *) &SwigClassHaltReasonChar);
  rb_define_alloc_func(SwigClassHaltReasonChar.klass, _wrap_HaltReasonChar_allocate);
  rb_define_method(SwigClassHaltReasonChar.klass, "initialize", VALUEFUNC(_wrap_new_HaltReasonChar), -1);
  SwigClassHaltReasonChar.mark = 0;
  SwigClassHaltReasonChar.destroy = (void (*)(void *)) free_FIX_HaltReasonChar;
  SwigClassHaltReasonChar.trackObjects = 0;
  
  SwigClassExDestination.klass = rb_define_class_under(mQuickfix, "ExDestination", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExDestination, (void *) &SwigClassExDestination);
  rb_define_alloc_func(SwigClassExDestination.klass, _wrap_ExDestination_allocate);
  rb_define_method(SwigClassExDestination.klass, "initialize", VALUEFUNC(_wrap_new_ExDestination), -1);
  SwigClassExDestination.mark = 0;
  SwigClassExDestination.destroy = (void (*)(void *)) free_FIX_ExDestination;
  SwigClassExDestination.trackObjects = 0;
  
  SwigClassDerivativeInstrmtAssignmentMethod.klass = rb_define_class_under(mQuickfix, "DerivativeInstrmtAssignmentMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod, (void *) &SwigClassDerivativeInstrmtAssignmentMethod);
  rb_define_alloc_func(SwigClassDerivativeInstrmtAssignmentMethod.klass, _wrap_DerivativeInstrmtAssignmentMethod_allocate);
  rb_define_method(SwigClassDerivativeInstrmtAssignmentMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrmtAssignmentMethod), -1);
  SwigClassDerivativeInstrmtAssignmentMethod.mark = 0;
  SwigClassDerivativeInstrmtAssignmentMethod.destroy = (void (*)(void *)) free_FIX_DerivativeInstrmtAssignmentMethod;
  SwigClassDerivativeInstrmtAssignmentMethod.trackObjects = 0;
  
  SwigClassUnderlyingIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingIDSource, (void *) &SwigClassUnderlyingIDSource);
  rb_define_alloc_func(SwigClassUnderlyingIDSource.klass, _wrap_UnderlyingIDSource_allocate);
  rb_define_method(SwigClassUnderlyingIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingIDSource), -1);
  SwigClassUnderlyingIDSource.mark = 0;
  SwigClassUnderlyingIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingIDSource;
  SwigClassUnderlyingIDSource.trackObjects = 0;
  
  SwigClassAdvId.klass = rb_define_class_under(mQuickfix, "AdvId", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvId, (void *) &SwigClassAdvId);
  rb_define_alloc_func(SwigClassAdvId.klass, _wrap_AdvId_allocate);
  rb_define_method(SwigClassAdvId.klass, "initialize", VALUEFUNC(_wrap_new_AdvId), -1);
  SwigClassAdvId.mark = 0;
  SwigClassAdvId.destroy = (void (*)(void *)) free_FIX_AdvId;
  SwigClassAdvId.trackObjects = 0;
  
  SwigClassTransBkdTime.klass = rb_define_class_under(mQuickfix, "TransBkdTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TransBkdTime, (void *) &SwigClassTransBkdTime);
  rb_define_alloc_func(SwigClassTransBkdTime.klass, _wrap_TransBkdTime_allocate);
  rb_define_method(SwigClassTransBkdTime.klass, "initialize", VALUEFUNC(_wrap_new_TransBkdTime), -1);
  SwigClassTransBkdTime.mark = 0;
  SwigClassTransBkdTime.destroy = (void (*)(void *)) free_FIX_TransBkdTime;
  SwigClassTransBkdTime.trackObjects = 0;
  
  SwigClassLegLastPx.klass = rb_define_class_under(mQuickfix, "LegLastPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLastPx, (void *) &SwigClassLegLastPx);
  rb_define_alloc_func(SwigClassLegLastPx.klass, _wrap_LegLastPx_allocate);
  rb_define_method(SwigClassLegLastPx.klass, "initialize", VALUEFUNC(_wrap_new_LegLastPx), -1);
  SwigClassLegLastPx.mark = 0;
  SwigClassLegLastPx.destroy = (void (*)(void *)) free_FIX_LegLastPx;
  SwigClassLegLastPx.trackObjects = 0;
  
  SwigClassAllocReportType.klass = rb_define_class_under(mQuickfix, "AllocReportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocReportType, (void *) &SwigClassAllocReportType);
  rb_define_alloc_func(SwigClassAllocReportType.klass, _wrap_AllocReportType_allocate);
  rb_define_method(SwigClassAllocReportType.klass, "initialize", VALUEFUNC(_wrap_new_AllocReportType), -1);
  SwigClassAllocReportType.mark = 0;
  SwigClassAllocReportType.destroy = (void (*)(void *)) free_FIX_AllocReportType;
  SwigClassAllocReportType.trackObjects = 0;
  
  SwigClassRegistDtls.klass = rb_define_class_under(mQuickfix, "RegistDtls", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistDtls, (void *) &SwigClassRegistDtls);
  rb_define_alloc_func(SwigClassRegistDtls.klass, _wrap_RegistDtls_allocate);
  rb_define_method(SwigClassRegistDtls.klass, "initialize", VALUEFUNC(_wrap_new_RegistDtls), -1);
  SwigClassRegistDtls.mark = 0;
  SwigClassRegistDtls.destroy = (void (*)(void *)) free_FIX_RegistDtls;
  SwigClassRegistDtls.trackObjects = 0;
  
  SwigClassAllocType.klass = rb_define_class_under(mQuickfix, "AllocType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocType, (void *) &SwigClassAllocType);
  rb_define_alloc_func(SwigClassAllocType.klass, _wrap_AllocType_allocate);
  rb_define_method(SwigClassAllocType.klass, "initialize", VALUEFUNC(_wrap_new_AllocType), -1);
  SwigClassAllocType.mark = 0;
  SwigClassAllocType.destroy = (void (*)(void *)) free_FIX_AllocType;
  SwigClassAllocType.trackObjects = 0;
  
  SwigClassQuoteRequestRejectReason.klass = rb_define_class_under(mQuickfix, "QuoteRequestRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRequestRejectReason, (void *) &SwigClassQuoteRequestRejectReason);
  rb_define_alloc_func(SwigClassQuoteRequestRejectReason.klass, _wrap_QuoteRequestRejectReason_allocate);
  rb_define_method(SwigClassQuoteRequestRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRequestRejectReason), -1);
  SwigClassQuoteRequestRejectReason.mark = 0;
  SwigClassQuoteRequestRejectReason.destroy = (void (*)(void *)) free_FIX_QuoteRequestRejectReason;
  SwigClassQuoteRequestRejectReason.trackObjects = 0;
  
  SwigClassUnderlyingUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "UnderlyingUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure, (void *) &SwigClassUnderlyingUnitOfMeasure);
  rb_define_alloc_func(SwigClassUnderlyingUnitOfMeasure.klass, _wrap_UnderlyingUnitOfMeasure_allocate);
  rb_define_method(SwigClassUnderlyingUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingUnitOfMeasure), -1);
  SwigClassUnderlyingUnitOfMeasure.mark = 0;
  SwigClassUnderlyingUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_UnderlyingUnitOfMeasure;
  SwigClassUnderlyingUnitOfMeasure.trackObjects = 0;
  
  SwigClassIndividualAllocID.klass = rb_define_class_under(mQuickfix, "IndividualAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IndividualAllocID, (void *) &SwigClassIndividualAllocID);
  rb_define_alloc_func(SwigClassIndividualAllocID.klass, _wrap_IndividualAllocID_allocate);
  rb_define_method(SwigClassIndividualAllocID.klass, "initialize", VALUEFUNC(_wrap_new_IndividualAllocID), -1);
  SwigClassIndividualAllocID.mark = 0;
  SwigClassIndividualAllocID.destroy = (void (*)(void *)) free_FIX_IndividualAllocID;
  SwigClassIndividualAllocID.trackObjects = 0;
  
  SwigClassLegOfferPx.klass = rb_define_class_under(mQuickfix, "LegOfferPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOfferPx, (void *) &SwigClassLegOfferPx);
  rb_define_alloc_func(SwigClassLegOfferPx.klass, _wrap_LegOfferPx_allocate);
  rb_define_method(SwigClassLegOfferPx.klass, "initialize", VALUEFUNC(_wrap_new_LegOfferPx), -1);
  SwigClassLegOfferPx.mark = 0;
  SwigClassLegOfferPx.destroy = (void (*)(void *)) free_FIX_LegOfferPx;
  SwigClassLegOfferPx.trackObjects = 0;
  
  SwigClassLiquidityIndType.klass = rb_define_class_under(mQuickfix, "LiquidityIndType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityIndType, (void *) &SwigClassLiquidityIndType);
  rb_define_alloc_func(SwigClassLiquidityIndType.klass, _wrap_LiquidityIndType_allocate);
  rb_define_method(SwigClassLiquidityIndType.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityIndType), -1);
  SwigClassLiquidityIndType.mark = 0;
  SwigClassLiquidityIndType.destroy = (void (*)(void *)) free_FIX_LiquidityIndType;
  SwigClassLiquidityIndType.trackObjects = 0;
  
  SwigClassHopSendingTime.klass = rb_define_class_under(mQuickfix, "HopSendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HopSendingTime, (void *) &SwigClassHopSendingTime);
  rb_define_alloc_func(SwigClassHopSendingTime.klass, _wrap_HopSendingTime_allocate);
  rb_define_method(SwigClassHopSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_HopSendingTime), -1);
  SwigClassHopSendingTime.mark = 0;
  SwigClassHopSendingTime.destroy = (void (*)(void *)) free_FIX_HopSendingTime;
  SwigClassHopSendingTime.trackObjects = 0;
  
  SwigClassApplResendFlag.klass = rb_define_class_under(mQuickfix, "ApplResendFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResendFlag, (void *) &SwigClassApplResendFlag);
  rb_define_alloc_func(SwigClassApplResendFlag.klass, _wrap_ApplResendFlag_allocate);
  rb_define_method(SwigClassApplResendFlag.klass, "initialize", VALUEFUNC(_wrap_new_ApplResendFlag), -1);
  SwigClassApplResendFlag.mark = 0;
  SwigClassApplResendFlag.destroy = (void (*)(void *)) free_FIX_ApplResendFlag;
  SwigClassApplResendFlag.trackObjects = 0;
  
  SwigClassDerivativeCapPrice.klass = rb_define_class_under(mQuickfix, "DerivativeCapPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeCapPrice, (void *) &SwigClassDerivativeCapPrice);
  rb_define_alloc_func(SwigClassDerivativeCapPrice.klass, _wrap_DerivativeCapPrice_allocate);
  rb_define_method(SwigClassDerivativeCapPrice.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeCapPrice), -1);
  SwigClassDerivativeCapPrice.mark = 0;
  SwigClassDerivativeCapPrice.destroy = (void (*)(void *)) free_FIX_DerivativeCapPrice;
  SwigClassDerivativeCapPrice.trackObjects = 0;
  
  SwigClassComplexOptPayoutAmount.klass = rb_define_class_under(mQuickfix, "ComplexOptPayoutAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexOptPayoutAmount, (void *) &SwigClassComplexOptPayoutAmount);
  rb_define_alloc_func(SwigClassComplexOptPayoutAmount.klass, _wrap_ComplexOptPayoutAmount_allocate);
  rb_define_method(SwigClassComplexOptPayoutAmount.klass, "initialize", VALUEFUNC(_wrap_new_ComplexOptPayoutAmount), -1);
  SwigClassComplexOptPayoutAmount.mark = 0;
  SwigClassComplexOptPayoutAmount.destroy = (void (*)(void *)) free_FIX_ComplexOptPayoutAmount;
  SwigClassComplexOptPayoutAmount.trackObjects = 0;
  
  SwigClassLanguageCode.klass = rb_define_class_under(mQuickfix, "LanguageCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LanguageCode, (void *) &SwigClassLanguageCode);
  rb_define_alloc_func(SwigClassLanguageCode.klass, _wrap_LanguageCode_allocate);
  rb_define_method(SwigClassLanguageCode.klass, "initialize", VALUEFUNC(_wrap_new_LanguageCode), -1);
  SwigClassLanguageCode.mark = 0;
  SwigClassLanguageCode.destroy = (void (*)(void *)) free_FIX_LanguageCode;
  SwigClassLanguageCode.trackObjects = 0;
  
  SwigClassSettlObligRefID.klass = rb_define_class_under(mQuickfix, "SettlObligRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligRefID, (void *) &SwigClassSettlObligRefID);
  rb_define_alloc_func(SwigClassSettlObligRefID.klass, _wrap_SettlObligRefID_allocate);
  rb_define_method(SwigClassSettlObligRefID.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligRefID), -1);
  SwigClassSettlObligRefID.mark = 0;
  SwigClassSettlObligRefID.destroy = (void (*)(void *)) free_FIX_SettlObligRefID;
  SwigClassSettlObligRefID.trackObjects = 0;
  
  SwigClassOrigTradeID.klass = rb_define_class_under(mQuickfix, "OrigTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTradeID, (void *) &SwigClassOrigTradeID);
  rb_define_alloc_func(SwigClassOrigTradeID.klass, _wrap_OrigTradeID_allocate);
  rb_define_method(SwigClassOrigTradeID.klass, "initialize", VALUEFUNC(_wrap_new_OrigTradeID), -1);
  SwigClassOrigTradeID.mark = 0;
  SwigClassOrigTradeID.destroy = (void (*)(void *)) free_FIX_OrigTradeID;
  SwigClassOrigTradeID.trackObjects = 0;
  
  SwigClassUnderlyingCollectAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingCollectAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCollectAmount, (void *) &SwigClassUnderlyingCollectAmount);
  rb_define_alloc_func(SwigClassUnderlyingCollectAmount.klass, _wrap_UnderlyingCollectAmount_allocate);
  rb_define_method(SwigClassUnderlyingCollectAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCollectAmount), -1);
  SwigClassUnderlyingCollectAmount.mark = 0;
  SwigClassUnderlyingCollectAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingCollectAmount;
  SwigClassUnderlyingCollectAmount.trackObjects = 0;
  
  SwigClassStatusValue.klass = rb_define_class_under(mQuickfix, "StatusValue", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StatusValue, (void *) &SwigClassStatusValue);
  rb_define_alloc_func(SwigClassStatusValue.klass, _wrap_StatusValue_allocate);
  rb_define_method(SwigClassStatusValue.klass, "initialize", VALUEFUNC(_wrap_new_StatusValue), -1);
  SwigClassStatusValue.mark = 0;
  SwigClassStatusValue.destroy = (void (*)(void *)) free_FIX_StatusValue;
  SwigClassStatusValue.trackObjects = 0;
  
  SwigClassOfferSpotRate.klass = rb_define_class_under(mQuickfix, "OfferSpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferSpotRate, (void *) &SwigClassOfferSpotRate);
  rb_define_alloc_func(SwigClassOfferSpotRate.klass, _wrap_OfferSpotRate_allocate);
  rb_define_method(SwigClassOfferSpotRate.klass, "initialize", VALUEFUNC(_wrap_new_OfferSpotRate), -1);
  SwigClassOfferSpotRate.mark = 0;
  SwigClassOfferSpotRate.destroy = (void (*)(void *)) free_FIX_OfferSpotRate;
  SwigClassOfferSpotRate.trackObjects = 0;
  
  SwigClassPosType.klass = rb_define_class_under(mQuickfix, "PosType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosType, (void *) &SwigClassPosType);
  rb_define_alloc_func(SwigClassPosType.klass, _wrap_PosType_allocate);
  rb_define_method(SwigClassPosType.klass, "initialize", VALUEFUNC(_wrap_new_PosType), -1);
  SwigClassPosType.mark = 0;
  SwigClassPosType.destroy = (void (*)(void *)) free_FIX_PosType;
  SwigClassPosType.trackObjects = 0;
  
  SwigClassUnderlyingRedemptionDate.klass = rb_define_class_under(mQuickfix, "UnderlyingRedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRedemptionDate, (void *) &SwigClassUnderlyingRedemptionDate);
  rb_define_alloc_func(SwigClassUnderlyingRedemptionDate.klass, _wrap_UnderlyingRedemptionDate_allocate);
  rb_define_method(SwigClassUnderlyingRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRedemptionDate), -1);
  SwigClassUnderlyingRedemptionDate.mark = 0;
  SwigClassUnderlyingRedemptionDate.destroy = (void (*)(void *)) free_FIX_UnderlyingRedemptionDate;
  SwigClassUnderlyingRedemptionDate.trackObjects = 0;
  
  SwigClassSettlDepositoryCode.klass = rb_define_class_under(mQuickfix, "SettlDepositoryCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDepositoryCode, (void *) &SwigClassSettlDepositoryCode);
  rb_define_alloc_func(SwigClassSettlDepositoryCode.klass, _wrap_SettlDepositoryCode_allocate);
  rb_define_method(SwigClassSettlDepositoryCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlDepositoryCode), -1);
  SwigClassSettlDepositoryCode.mark = 0;
  SwigClassSettlDepositoryCode.destroy = (void (*)(void *)) free_FIX_SettlDepositoryCode;
  SwigClassSettlDepositoryCode.trackObjects = 0;
  
  SwigClassStreamAsgnAckType.klass = rb_define_class_under(mQuickfix, "StreamAsgnAckType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnAckType, (void *) &SwigClassStreamAsgnAckType);
  rb_define_alloc_func(SwigClassStreamAsgnAckType.klass, _wrap_StreamAsgnAckType_allocate);
  rb_define_method(SwigClassStreamAsgnAckType.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnAckType), -1);
  SwigClassStreamAsgnAckType.mark = 0;
  SwigClassStreamAsgnAckType.destroy = (void (*)(void *)) free_FIX_StreamAsgnAckType;
  SwigClassStreamAsgnAckType.trackObjects = 0;
  
  SwigClassFloorPrice.klass = rb_define_class_under(mQuickfix, "FloorPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FloorPrice, (void *) &SwigClassFloorPrice);
  rb_define_alloc_func(SwigClassFloorPrice.klass, _wrap_FloorPrice_allocate);
  rb_define_method(SwigClassFloorPrice.klass, "initialize", VALUEFUNC(_wrap_new_FloorPrice), -1);
  SwigClassFloorPrice.mark = 0;
  SwigClassFloorPrice.destroy = (void (*)(void *)) free_FIX_FloorPrice;
  SwigClassFloorPrice.trackObjects = 0;
  
  SwigClassUnderlyingPriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "UnderlyingPriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty, (void *) &SwigClassUnderlyingPriceUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassUnderlyingPriceUnitOfMeasureQty.klass, _wrap_UnderlyingPriceUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassUnderlyingPriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPriceUnitOfMeasureQty), -1);
  SwigClassUnderlyingPriceUnitOfMeasureQty.mark = 0;
  SwigClassUnderlyingPriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_UnderlyingPriceUnitOfMeasureQty;
  SwigClassUnderlyingPriceUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassFeeMultiplier.klass = rb_define_class_under(mQuickfix, "FeeMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FeeMultiplier, (void *) &SwigClassFeeMultiplier);
  rb_define_alloc_func(SwigClassFeeMultiplier.klass, _wrap_FeeMultiplier_allocate);
  rb_define_method(SwigClassFeeMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_FeeMultiplier), -1);
  SwigClassFeeMultiplier.mark = 0;
  SwigClassFeeMultiplier.destroy = (void (*)(void *)) free_FIX_FeeMultiplier;
  SwigClassFeeMultiplier.trackObjects = 0;
  
  SwigClassUnderlyingMaturityTime.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityTime, (void *) &SwigClassUnderlyingMaturityTime);
  rb_define_alloc_func(SwigClassUnderlyingMaturityTime.klass, _wrap_UnderlyingMaturityTime_allocate);
  rb_define_method(SwigClassUnderlyingMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityTime), -1);
  SwigClassUnderlyingMaturityTime.mark = 0;
  SwigClassUnderlyingMaturityTime.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityTime;
  SwigClassUnderlyingMaturityTime.trackObjects = 0;
  
  SwigClassApplID.klass = rb_define_class_under(mQuickfix, "ApplID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplID, (void *) &SwigClassApplID);
  rb_define_alloc_func(SwigClassApplID.klass, _wrap_ApplID_allocate);
  rb_define_method(SwigClassApplID.klass, "initialize", VALUEFUNC(_wrap_new_ApplID), -1);
  SwigClassApplID.mark = 0;
  SwigClassApplID.destroy = (void (*)(void *)) free_FIX_ApplID;
  SwigClassApplID.trackObjects = 0;
  
  SwigClassLegGrossTradeAmt.klass = rb_define_class_under(mQuickfix, "LegGrossTradeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegGrossTradeAmt, (void *) &SwigClassLegGrossTradeAmt);
  rb_define_alloc_func(SwigClassLegGrossTradeAmt.klass, _wrap_LegGrossTradeAmt_allocate);
  rb_define_method(SwigClassLegGrossTradeAmt.klass, "initialize", VALUEFUNC(_wrap_new_LegGrossTradeAmt), -1);
  SwigClassLegGrossTradeAmt.mark = 0;
  SwigClassLegGrossTradeAmt.destroy = (void (*)(void *)) free_FIX_LegGrossTradeAmt;
  SwigClassLegGrossTradeAmt.trackObjects = 0;
  
  SwigClassMDEntryDate.klass = rb_define_class_under(mQuickfix, "MDEntryDate", ((swig_class *) SWIGTYPE_p_FIX__UtcDateField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryDate, (void *) &SwigClassMDEntryDate);
  rb_define_alloc_func(SwigClassMDEntryDate.klass, _wrap_MDEntryDate_allocate);
  rb_define_method(SwigClassMDEntryDate.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryDate), -1);
  SwigClassMDEntryDate.mark = 0;
  SwigClassMDEntryDate.destroy = (void (*)(void *)) free_FIX_MDEntryDate;
  SwigClassMDEntryDate.trackObjects = 0;
  
  SwigClassLegBenchmarkCurveCurrency.klass = rb_define_class_under(mQuickfix, "LegBenchmarkCurveCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency, (void *) &SwigClassLegBenchmarkCurveCurrency);
  rb_define_alloc_func(SwigClassLegBenchmarkCurveCurrency.klass, _wrap_LegBenchmarkCurveCurrency_allocate);
  rb_define_method(SwigClassLegBenchmarkCurveCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkCurveCurrency), -1);
  SwigClassLegBenchmarkCurveCurrency.mark = 0;
  SwigClassLegBenchmarkCurveCurrency.destroy = (void (*)(void *)) free_FIX_LegBenchmarkCurveCurrency;
  SwigClassLegBenchmarkCurveCurrency.trackObjects = 0;
  
  SwigClassOptPayoutAmount.klass = rb_define_class_under(mQuickfix, "OptPayoutAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptPayoutAmount, (void *) &SwigClassOptPayoutAmount);
  rb_define_alloc_func(SwigClassOptPayoutAmount.klass, _wrap_OptPayoutAmount_allocate);
  rb_define_method(SwigClassOptPayoutAmount.klass, "initialize", VALUEFUNC(_wrap_new_OptPayoutAmount), -1);
  SwigClassOptPayoutAmount.mark = 0;
  SwigClassOptPayoutAmount.destroy = (void (*)(void *)) free_FIX_OptPayoutAmount;
  SwigClassOptPayoutAmount.trackObjects = 0;
  
  SwigClassMiscFeeBasis.klass = rb_define_class_under(mQuickfix, "MiscFeeBasis", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeBasis, (void *) &SwigClassMiscFeeBasis);
  rb_define_alloc_func(SwigClassMiscFeeBasis.klass, _wrap_MiscFeeBasis_allocate);
  rb_define_method(SwigClassMiscFeeBasis.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeBasis), -1);
  SwigClassMiscFeeBasis.mark = 0;
  SwigClassMiscFeeBasis.destroy = (void (*)(void *)) free_FIX_MiscFeeBasis;
  SwigClassMiscFeeBasis.trackObjects = 0;
  
  SwigClassValidUntilTime.klass = rb_define_class_under(mQuickfix, "ValidUntilTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ValidUntilTime, (void *) &SwigClassValidUntilTime);
  rb_define_alloc_func(SwigClassValidUntilTime.klass, _wrap_ValidUntilTime_allocate);
  rb_define_method(SwigClassValidUntilTime.klass, "initialize", VALUEFUNC(_wrap_new_ValidUntilTime), -1);
  SwigClassValidUntilTime.mark = 0;
  SwigClassValidUntilTime.destroy = (void (*)(void *)) free_FIX_ValidUntilTime;
  SwigClassValidUntilTime.trackObjects = 0;
  
  SwigClassOrdType.klass = rb_define_class_under(mQuickfix, "OrdType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdType, (void *) &SwigClassOrdType);
  rb_define_alloc_func(SwigClassOrdType.klass, _wrap_OrdType_allocate);
  rb_define_method(SwigClassOrdType.klass, "initialize", VALUEFUNC(_wrap_new_OrdType), -1);
  SwigClassOrdType.mark = 0;
  SwigClassOrdType.destroy = (void (*)(void *)) free_FIX_OrdType;
  SwigClassOrdType.trackObjects = 0;
  
  SwigClassAdvRefID.klass = rb_define_class_under(mQuickfix, "AdvRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvRefID, (void *) &SwigClassAdvRefID);
  rb_define_alloc_func(SwigClassAdvRefID.klass, _wrap_AdvRefID_allocate);
  rb_define_method(SwigClassAdvRefID.klass, "initialize", VALUEFUNC(_wrap_new_AdvRefID), -1);
  SwigClassAdvRefID.mark = 0;
  SwigClassAdvRefID.destroy = (void (*)(void *)) free_FIX_AdvRefID;
  SwigClassAdvRefID.trackObjects = 0;
  
  SwigClassHopCompID.klass = rb_define_class_under(mQuickfix, "HopCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HopCompID, (void *) &SwigClassHopCompID);
  rb_define_alloc_func(SwigClassHopCompID.klass, _wrap_HopCompID_allocate);
  rb_define_method(SwigClassHopCompID.klass, "initialize", VALUEFUNC(_wrap_new_HopCompID), -1);
  SwigClassHopCompID.mark = 0;
  SwigClassHopCompID.destroy = (void (*)(void *)) free_FIX_HopCompID;
  SwigClassHopCompID.trackObjects = 0;
  
  SwigClassPosMaintRptRefID.klass = rb_define_class_under(mQuickfix, "PosMaintRptRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintRptRefID, (void *) &SwigClassPosMaintRptRefID);
  rb_define_alloc_func(SwigClassPosMaintRptRefID.klass, _wrap_PosMaintRptRefID_allocate);
  rb_define_method(SwigClassPosMaintRptRefID.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintRptRefID), -1);
  SwigClassPosMaintRptRefID.mark = 0;
  SwigClassPosMaintRptRefID.destroy = (void (*)(void *)) free_FIX_PosMaintRptRefID;
  SwigClassPosMaintRptRefID.trackObjects = 0;
  
  SwigClassLegStipulationValue.klass = rb_define_class_under(mQuickfix, "LegStipulationValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStipulationValue, (void *) &SwigClassLegStipulationValue);
  rb_define_alloc_func(SwigClassLegStipulationValue.klass, _wrap_LegStipulationValue_allocate);
  rb_define_method(SwigClassLegStipulationValue.klass, "initialize", VALUEFUNC(_wrap_new_LegStipulationValue), -1);
  SwigClassLegStipulationValue.mark = 0;
  SwigClassLegStipulationValue.destroy = (void (*)(void *)) free_FIX_LegStipulationValue;
  SwigClassLegStipulationValue.trackObjects = 0;
  
  SwigClassMatchType.klass = rb_define_class_under(mQuickfix, "MatchType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchType, (void *) &SwigClassMatchType);
  rb_define_alloc_func(SwigClassMatchType.klass, _wrap_MatchType_allocate);
  rb_define_method(SwigClassMatchType.klass, "initialize", VALUEFUNC(_wrap_new_MatchType), -1);
  SwigClassMatchType.mark = 0;
  SwigClassMatchType.destroy = (void (*)(void *)) free_FIX_MatchType;
  SwigClassMatchType.trackObjects = 0;
  
  SwigClassOptPayoutType.klass = rb_define_class_under(mQuickfix, "OptPayoutType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptPayoutType, (void *) &SwigClassOptPayoutType);
  rb_define_alloc_func(SwigClassOptPayoutType.klass, _wrap_OptPayoutType_allocate);
  rb_define_method(SwigClassOptPayoutType.klass, "initialize", VALUEFUNC(_wrap_new_OptPayoutType), -1);
  SwigClassOptPayoutType.mark = 0;
  SwigClassOptPayoutType.destroy = (void (*)(void *)) free_FIX_OptPayoutType;
  SwigClassOptPayoutType.trackObjects = 0;
  
  SwigClassUnderlyingPriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "UnderlyingPriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure, (void *) &SwigClassUnderlyingPriceUnitOfMeasure);
  rb_define_alloc_func(SwigClassUnderlyingPriceUnitOfMeasure.klass, _wrap_UnderlyingPriceUnitOfMeasure_allocate);
  rb_define_method(SwigClassUnderlyingPriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPriceUnitOfMeasure), -1);
  SwigClassUnderlyingPriceUnitOfMeasure.mark = 0;
  SwigClassUnderlyingPriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_UnderlyingPriceUnitOfMeasure;
  SwigClassUnderlyingPriceUnitOfMeasure.trackObjects = 0;
  
  SwigClassMarketUpdateAction.klass = rb_define_class_under(mQuickfix, "MarketUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketUpdateAction, (void *) &SwigClassMarketUpdateAction);
  rb_define_alloc_func(SwigClassMarketUpdateAction.klass, _wrap_MarketUpdateAction_allocate);
  rb_define_method(SwigClassMarketUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_MarketUpdateAction), -1);
  SwigClassMarketUpdateAction.mark = 0;
  SwigClassMarketUpdateAction.destroy = (void (*)(void *)) free_FIX_MarketUpdateAction;
  SwigClassMarketUpdateAction.trackObjects = 0;
  
  SwigClassCollAsgnRejectReason.klass = rb_define_class_under(mQuickfix, "CollAsgnRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnRejectReason, (void *) &SwigClassCollAsgnRejectReason);
  rb_define_alloc_func(SwigClassCollAsgnRejectReason.klass, _wrap_CollAsgnRejectReason_allocate);
  rb_define_method(SwigClassCollAsgnRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnRejectReason), -1);
  SwigClassCollAsgnRejectReason.mark = 0;
  SwigClassCollAsgnRejectReason.destroy = (void (*)(void *)) free_FIX_CollAsgnRejectReason;
  SwigClassCollAsgnRejectReason.trackObjects = 0;
  
  SwigClassPeggedRefPrice.klass = rb_define_class_under(mQuickfix, "PeggedRefPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PeggedRefPrice, (void *) &SwigClassPeggedRefPrice);
  rb_define_alloc_func(SwigClassPeggedRefPrice.klass, _wrap_PeggedRefPrice_allocate);
  rb_define_method(SwigClassPeggedRefPrice.klass, "initialize", VALUEFUNC(_wrap_new_PeggedRefPrice), -1);
  SwigClassPeggedRefPrice.mark = 0;
  SwigClassPeggedRefPrice.destroy = (void (*)(void *)) free_FIX_PeggedRefPrice;
  SwigClassPeggedRefPrice.trackObjects = 0;
  
  SwigClassIndividualAllocType.klass = rb_define_class_under(mQuickfix, "IndividualAllocType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IndividualAllocType, (void *) &SwigClassIndividualAllocType);
  rb_define_alloc_func(SwigClassIndividualAllocType.klass, _wrap_IndividualAllocType_allocate);
  rb_define_method(SwigClassIndividualAllocType.klass, "initialize", VALUEFUNC(_wrap_new_IndividualAllocType), -1);
  SwigClassIndividualAllocType.mark = 0;
  SwigClassIndividualAllocType.destroy = (void (*)(void *)) free_FIX_IndividualAllocType;
  SwigClassIndividualAllocType.trackObjects = 0;
  
  SwigClassEndCash.klass = rb_define_class_under(mQuickfix, "EndCash", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndCash, (void *) &SwigClassEndCash);
  rb_define_alloc_func(SwigClassEndCash.klass, _wrap_EndCash_allocate);
  rb_define_method(SwigClassEndCash.klass, "initialize", VALUEFUNC(_wrap_new_EndCash), -1);
  SwigClassEndCash.mark = 0;
  SwigClassEndCash.destroy = (void (*)(void *)) free_FIX_EndCash;
  SwigClassEndCash.trackObjects = 0;
  
  SwigClassEventText.klass = rb_define_class_under(mQuickfix, "EventText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventText, (void *) &SwigClassEventText);
  rb_define_alloc_func(SwigClassEventText.klass, _wrap_EventText_allocate);
  rb_define_method(SwigClassEventText.klass, "initialize", VALUEFUNC(_wrap_new_EventText), -1);
  SwigClassEventText.mark = 0;
  SwigClassEventText.destroy = (void (*)(void *)) free_FIX_EventText;
  SwigClassEventText.trackObjects = 0;
  
  SwigClassExDate.klass = rb_define_class_under(mQuickfix, "ExDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExDate, (void *) &SwigClassExDate);
  rb_define_alloc_func(SwigClassExDate.klass, _wrap_ExDate_allocate);
  rb_define_method(SwigClassExDate.klass, "initialize", VALUEFUNC(_wrap_new_ExDate), -1);
  SwigClassExDate.mark = 0;
  SwigClassExDate.destroy = (void (*)(void *)) free_FIX_ExDate;
  SwigClassExDate.trackObjects = 0;
  
  SwigClassNestedPartyIDSource.klass = rb_define_class_under(mQuickfix, "NestedPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartyIDSource, (void *) &SwigClassNestedPartyIDSource);
  rb_define_alloc_func(SwigClassNestedPartyIDSource.klass, _wrap_NestedPartyIDSource_allocate);
  rb_define_method(SwigClassNestedPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartyIDSource), -1);
  SwigClassNestedPartyIDSource.mark = 0;
  SwigClassNestedPartyIDSource.destroy = (void (*)(void *)) free_FIX_NestedPartyIDSource;
  SwigClassNestedPartyIDSource.trackObjects = 0;
  
  SwigClassGTBookingInst.klass = rb_define_class_under(mQuickfix, "GTBookingInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__GTBookingInst, (void *) &SwigClassGTBookingInst);
  rb_define_alloc_func(SwigClassGTBookingInst.klass, _wrap_GTBookingInst_allocate);
  rb_define_method(SwigClassGTBookingInst.klass, "initialize", VALUEFUNC(_wrap_new_GTBookingInst), -1);
  SwigClassGTBookingInst.mark = 0;
  SwigClassGTBookingInst.destroy = (void (*)(void *)) free_FIX_GTBookingInst;
  SwigClassGTBookingInst.trackObjects = 0;
  
  SwigClassDerivativeValuationMethod.klass = rb_define_class_under(mQuickfix, "DerivativeValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeValuationMethod, (void *) &SwigClassDerivativeValuationMethod);
  rb_define_alloc_func(SwigClassDerivativeValuationMethod.klass, _wrap_DerivativeValuationMethod_allocate);
  rb_define_method(SwigClassDerivativeValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeValuationMethod), -1);
  SwigClassDerivativeValuationMethod.mark = 0;
  SwigClassDerivativeValuationMethod.destroy = (void (*)(void *)) free_FIX_DerivativeValuationMethod;
  SwigClassDerivativeValuationMethod.trackObjects = 0;
  
  SwigClassNumberOfOrders.klass = rb_define_class_under(mQuickfix, "NumberOfOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumberOfOrders, (void *) &SwigClassNumberOfOrders);
  rb_define_alloc_func(SwigClassNumberOfOrders.klass, _wrap_NumberOfOrders_allocate);
  rb_define_method(SwigClassNumberOfOrders.klass, "initialize", VALUEFUNC(_wrap_new_NumberOfOrders), -1);
  SwigClassNumberOfOrders.mark = 0;
  SwigClassNumberOfOrders.destroy = (void (*)(void *)) free_FIX_NumberOfOrders;
  SwigClassNumberOfOrders.trackObjects = 0;
  
  SwigClassTrdRepPartyRole.klass = rb_define_class_under(mQuickfix, "TrdRepPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRepPartyRole, (void *) &SwigClassTrdRepPartyRole);
  rb_define_alloc_func(SwigClassTrdRepPartyRole.klass, _wrap_TrdRepPartyRole_allocate);
  rb_define_method(SwigClassTrdRepPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_TrdRepPartyRole), -1);
  SwigClassTrdRepPartyRole.mark = 0;
  SwigClassTrdRepPartyRole.destroy = (void (*)(void *)) free_FIX_TrdRepPartyRole;
  SwigClassTrdRepPartyRole.trackObjects = 0;
  
  SwigClassTriggerPrice.klass = rb_define_class_under(mQuickfix, "TriggerPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPrice, (void *) &SwigClassTriggerPrice);
  rb_define_alloc_func(SwigClassTriggerPrice.klass, _wrap_TriggerPrice_allocate);
  rb_define_method(SwigClassTriggerPrice.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPrice), -1);
  SwigClassTriggerPrice.mark = 0;
  SwigClassTriggerPrice.destroy = (void (*)(void *)) free_FIX_TriggerPrice;
  SwigClassTriggerPrice.trackObjects = 0;
  
  SwigClassMDReportID.klass = rb_define_class_under(mQuickfix, "MDReportID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDReportID, (void *) &SwigClassMDReportID);
  rb_define_alloc_func(SwigClassMDReportID.klass, _wrap_MDReportID_allocate);
  rb_define_method(SwigClassMDReportID.klass, "initialize", VALUEFUNC(_wrap_new_MDReportID), -1);
  SwigClassMDReportID.mark = 0;
  SwigClassMDReportID.destroy = (void (*)(void *)) free_FIX_MDReportID;
  SwigClassMDReportID.trackObjects = 0;
  
  SwigClassSecondaryAllocID.klass = rb_define_class_under(mQuickfix, "SecondaryAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryAllocID, (void *) &SwigClassSecondaryAllocID);
  rb_define_alloc_func(SwigClassSecondaryAllocID.klass, _wrap_SecondaryAllocID_allocate);
  rb_define_method(SwigClassSecondaryAllocID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryAllocID), -1);
  SwigClassSecondaryAllocID.mark = 0;
  SwigClassSecondaryAllocID.destroy = (void (*)(void *)) free_FIX_SecondaryAllocID;
  SwigClassSecondaryAllocID.trackObjects = 0;
  
  SwigClassLeavesQty.klass = rb_define_class_under(mQuickfix, "LeavesQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LeavesQty, (void *) &SwigClassLeavesQty);
  rb_define_alloc_func(SwigClassLeavesQty.klass, _wrap_LeavesQty_allocate);
  rb_define_method(SwigClassLeavesQty.klass, "initialize", VALUEFUNC(_wrap_new_LeavesQty), -1);
  SwigClassLeavesQty.mark = 0;
  SwigClassLeavesQty.destroy = (void (*)(void *)) free_FIX_LeavesQty;
  SwigClassLeavesQty.trackObjects = 0;
  
  SwigClassCardStartDate.klass = rb_define_class_under(mQuickfix, "CardStartDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardStartDate, (void *) &SwigClassCardStartDate);
  rb_define_alloc_func(SwigClassCardStartDate.klass, _wrap_CardStartDate_allocate);
  rb_define_method(SwigClassCardStartDate.klass, "initialize", VALUEFUNC(_wrap_new_CardStartDate), -1);
  SwigClassCardStartDate.mark = 0;
  SwigClassCardStartDate.destroy = (void (*)(void *)) free_FIX_CardStartDate;
  SwigClassCardStartDate.trackObjects = 0;
  
  SwigClassLegCoveredOrUncovered.klass = rb_define_class_under(mQuickfix, "LegCoveredOrUncovered", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCoveredOrUncovered, (void *) &SwigClassLegCoveredOrUncovered);
  rb_define_alloc_func(SwigClassLegCoveredOrUncovered.klass, _wrap_LegCoveredOrUncovered_allocate);
  rb_define_method(SwigClassLegCoveredOrUncovered.klass, "initialize", VALUEFUNC(_wrap_new_LegCoveredOrUncovered), -1);
  SwigClassLegCoveredOrUncovered.mark = 0;
  SwigClassLegCoveredOrUncovered.destroy = (void (*)(void *)) free_FIX_LegCoveredOrUncovered;
  SwigClassLegCoveredOrUncovered.trackObjects = 0;
  
  SwigClassPutOrCall.klass = rb_define_class_under(mQuickfix, "PutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PutOrCall, (void *) &SwigClassPutOrCall);
  rb_define_alloc_func(SwigClassPutOrCall.klass, _wrap_PutOrCall_allocate);
  rb_define_method(SwigClassPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_PutOrCall), -1);
  SwigClassPutOrCall.mark = 0;
  SwigClassPutOrCall.destroy = (void (*)(void *)) free_FIX_PutOrCall;
  SwigClassPutOrCall.trackObjects = 0;
  
  SwigClassMatchAlgorithm.klass = rb_define_class_under(mQuickfix, "MatchAlgorithm", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchAlgorithm, (void *) &SwigClassMatchAlgorithm);
  rb_define_alloc_func(SwigClassMatchAlgorithm.klass, _wrap_MatchAlgorithm_allocate);
  rb_define_method(SwigClassMatchAlgorithm.klass, "initialize", VALUEFUNC(_wrap_new_MatchAlgorithm), -1);
  SwigClassMatchAlgorithm.mark = 0;
  SwigClassMatchAlgorithm.destroy = (void (*)(void *)) free_FIX_MatchAlgorithm;
  SwigClassMatchAlgorithm.trackObjects = 0;
  
  SwigClassCalculatedCcyLastQty.klass = rb_define_class_under(mQuickfix, "CalculatedCcyLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CalculatedCcyLastQty, (void *) &SwigClassCalculatedCcyLastQty);
  rb_define_alloc_func(SwigClassCalculatedCcyLastQty.klass, _wrap_CalculatedCcyLastQty_allocate);
  rb_define_method(SwigClassCalculatedCcyLastQty.klass, "initialize", VALUEFUNC(_wrap_new_CalculatedCcyLastQty), -1);
  SwigClassCalculatedCcyLastQty.mark = 0;
  SwigClassCalculatedCcyLastQty.destroy = (void (*)(void *)) free_FIX_CalculatedCcyLastQty;
  SwigClassCalculatedCcyLastQty.trackObjects = 0;
  
  SwigClassFundRenewWaiv.klass = rb_define_class_under(mQuickfix, "FundRenewWaiv", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FundRenewWaiv, (void *) &SwigClassFundRenewWaiv);
  rb_define_alloc_func(SwigClassFundRenewWaiv.klass, _wrap_FundRenewWaiv_allocate);
  rb_define_method(SwigClassFundRenewWaiv.klass, "initialize", VALUEFUNC(_wrap_new_FundRenewWaiv), -1);
  SwigClassFundRenewWaiv.mark = 0;
  SwigClassFundRenewWaiv.destroy = (void (*)(void *)) free_FIX_FundRenewWaiv;
  SwigClassFundRenewWaiv.trackObjects = 0;
  
  SwigClassSecuritySettlAgentName.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentName, (void *) &SwigClassSecuritySettlAgentName);
  rb_define_alloc_func(SwigClassSecuritySettlAgentName.klass, _wrap_SecuritySettlAgentName_allocate);
  rb_define_method(SwigClassSecuritySettlAgentName.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentName), -1);
  SwigClassSecuritySettlAgentName.mark = 0;
  SwigClassSecuritySettlAgentName.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentName;
  SwigClassSecuritySettlAgentName.trackObjects = 0;
  
  SwigClassBidDescriptor.klass = rb_define_class_under(mQuickfix, "BidDescriptor", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidDescriptor, (void *) &SwigClassBidDescriptor);
  rb_define_alloc_func(SwigClassBidDescriptor.klass, _wrap_BidDescriptor_allocate);
  rb_define_method(SwigClassBidDescriptor.klass, "initialize", VALUEFUNC(_wrap_new_BidDescriptor), -1);
  SwigClassBidDescriptor.mark = 0;
  SwigClassBidDescriptor.destroy = (void (*)(void *)) free_FIX_BidDescriptor;
  SwigClassBidDescriptor.trackObjects = 0;
  
  SwigClassMDStreamID.klass = rb_define_class_under(mQuickfix, "MDStreamID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDStreamID, (void *) &SwigClassMDStreamID);
  rb_define_alloc_func(SwigClassMDStreamID.klass, _wrap_MDStreamID_allocate);
  rb_define_method(SwigClassMDStreamID.klass, "initialize", VALUEFUNC(_wrap_new_MDStreamID), -1);
  SwigClassMDStreamID.mark = 0;
  SwigClassMDStreamID.destroy = (void (*)(void *)) free_FIX_MDStreamID;
  SwigClassMDStreamID.trackObjects = 0;
  
  SwigClassNoAsgnReqs.klass = rb_define_class_under(mQuickfix, "NoAsgnReqs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAsgnReqs, (void *) &SwigClassNoAsgnReqs);
  rb_define_alloc_func(SwigClassNoAsgnReqs.klass, _wrap_NoAsgnReqs_allocate);
  rb_define_method(SwigClassNoAsgnReqs.klass, "initialize", VALUEFUNC(_wrap_new_NoAsgnReqs), -1);
  SwigClassNoAsgnReqs.mark = 0;
  SwigClassNoAsgnReqs.destroy = (void (*)(void *)) free_FIX_NoAsgnReqs;
  SwigClassNoAsgnReqs.trackObjects = 0;
  
  SwigClassNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "NotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotionalPercentageOutstanding, (void *) &SwigClassNotionalPercentageOutstanding);
  rb_define_alloc_func(SwigClassNotionalPercentageOutstanding.klass, _wrap_NotionalPercentageOutstanding_allocate);
  rb_define_method(SwigClassNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_NotionalPercentageOutstanding), -1);
  SwigClassNotionalPercentageOutstanding.mark = 0;
  SwigClassNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_NotionalPercentageOutstanding;
  SwigClassNotionalPercentageOutstanding.trackObjects = 0;
  
  SwigClassNoSettlInst.klass = rb_define_class_under(mQuickfix, "NoSettlInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlInst, (void *) &SwigClassNoSettlInst);
  rb_define_alloc_func(SwigClassNoSettlInst.klass, _wrap_NoSettlInst_allocate);
  rb_define_method(SwigClassNoSettlInst.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlInst), -1);
  SwigClassNoSettlInst.mark = 0;
  SwigClassNoSettlInst.destroy = (void (*)(void *)) free_FIX_NoSettlInst;
  SwigClassNoSettlInst.trackObjects = 0;
  
  SwigClassSettlInstMsgID.klass = rb_define_class_under(mQuickfix, "SettlInstMsgID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstMsgID, (void *) &SwigClassSettlInstMsgID);
  rb_define_alloc_func(SwigClassSettlInstMsgID.klass, _wrap_SettlInstMsgID_allocate);
  rb_define_method(SwigClassSettlInstMsgID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstMsgID), -1);
  SwigClassSettlInstMsgID.mark = 0;
  SwigClassSettlInstMsgID.destroy = (void (*)(void *)) free_FIX_SettlInstMsgID;
  SwigClassSettlInstMsgID.trackObjects = 0;
  
  SwigClassForexReq.klass = rb_define_class_under(mQuickfix, "ForexReq", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ForexReq, (void *) &SwigClassForexReq);
  rb_define_alloc_func(SwigClassForexReq.klass, _wrap_ForexReq_allocate);
  rb_define_method(SwigClassForexReq.klass, "initialize", VALUEFUNC(_wrap_new_ForexReq), -1);
  SwigClassForexReq.mark = 0;
  SwigClassForexReq.destroy = (void (*)(void *)) free_FIX_ForexReq;
  SwigClassForexReq.trackObjects = 0;
  
  SwigClassTradSesReqID.klass = rb_define_class_under(mQuickfix, "TradSesReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesReqID, (void *) &SwigClassTradSesReqID);
  rb_define_alloc_func(SwigClassTradSesReqID.klass, _wrap_TradSesReqID_allocate);
  rb_define_method(SwigClassTradSesReqID.klass, "initialize", VALUEFUNC(_wrap_new_TradSesReqID), -1);
  SwigClassTradSesReqID.mark = 0;
  SwigClassTradSesReqID.destroy = (void (*)(void *)) free_FIX_TradSesReqID;
  SwigClassTradSesReqID.trackObjects = 0;
  
  SwigClassUnderlyingLegStrikePrice.klass = rb_define_class_under(mQuickfix, "UnderlyingLegStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegStrikePrice, (void *) &SwigClassUnderlyingLegStrikePrice);
  rb_define_alloc_func(SwigClassUnderlyingLegStrikePrice.klass, _wrap_UnderlyingLegStrikePrice_allocate);
  rb_define_method(SwigClassUnderlyingLegStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegStrikePrice), -1);
  SwigClassUnderlyingLegStrikePrice.mark = 0;
  SwigClassUnderlyingLegStrikePrice.destroy = (void (*)(void *)) free_FIX_UnderlyingLegStrikePrice;
  SwigClassUnderlyingLegStrikePrice.trackObjects = 0;
  
  SwigClassTickRuleType.klass = rb_define_class_under(mQuickfix, "TickRuleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TickRuleType, (void *) &SwigClassTickRuleType);
  rb_define_alloc_func(SwigClassTickRuleType.klass, _wrap_TickRuleType_allocate);
  rb_define_method(SwigClassTickRuleType.klass, "initialize", VALUEFUNC(_wrap_new_TickRuleType), -1);
  SwigClassTickRuleType.mark = 0;
  SwigClassTickRuleType.destroy = (void (*)(void *)) free_FIX_TickRuleType;
  SwigClassTickRuleType.trackObjects = 0;
  
  SwigClassInstrmtAssignmentMethod.klass = rb_define_class_under(mQuickfix, "InstrmtAssignmentMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrmtAssignmentMethod, (void *) &SwigClassInstrmtAssignmentMethod);
  rb_define_alloc_func(SwigClassInstrmtAssignmentMethod.klass, _wrap_InstrmtAssignmentMethod_allocate);
  rb_define_method(SwigClassInstrmtAssignmentMethod.klass, "initialize", VALUEFUNC(_wrap_new_InstrmtAssignmentMethod), -1);
  SwigClassInstrmtAssignmentMethod.mark = 0;
  SwigClassInstrmtAssignmentMethod.destroy = (void (*)(void *)) free_FIX_InstrmtAssignmentMethod;
  SwigClassInstrmtAssignmentMethod.trackObjects = 0;
  
  SwigClassDiscretionOffsetType.klass = rb_define_class_under(mQuickfix, "DiscretionOffsetType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionOffsetType, (void *) &SwigClassDiscretionOffsetType);
  rb_define_alloc_func(SwigClassDiscretionOffsetType.klass, _wrap_DiscretionOffsetType_allocate);
  rb_define_method(SwigClassDiscretionOffsetType.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionOffsetType), -1);
  SwigClassDiscretionOffsetType.mark = 0;
  SwigClassDiscretionOffsetType.destroy = (void (*)(void *)) free_FIX_DiscretionOffsetType;
  SwigClassDiscretionOffsetType.trackObjects = 0;
  
  SwigClassConfirmTransType.klass = rb_define_class_under(mQuickfix, "ConfirmTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmTransType, (void *) &SwigClassConfirmTransType);
  rb_define_alloc_func(SwigClassConfirmTransType.klass, _wrap_ConfirmTransType_allocate);
  rb_define_method(SwigClassConfirmTransType.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmTransType), -1);
  SwigClassConfirmTransType.mark = 0;
  SwigClassConfirmTransType.destroy = (void (*)(void *)) free_FIX_ConfirmTransType;
  SwigClassConfirmTransType.trackObjects = 0;
  
  SwigClassTotalTakedown.klass = rb_define_class_under(mQuickfix, "TotalTakedown", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalTakedown, (void *) &SwigClassTotalTakedown);
  rb_define_alloc_func(SwigClassTotalTakedown.klass, _wrap_TotalTakedown_allocate);
  rb_define_method(SwigClassTotalTakedown.klass, "initialize", VALUEFUNC(_wrap_new_TotalTakedown), -1);
  SwigClassTotalTakedown.mark = 0;
  SwigClassTotalTakedown.destroy = (void (*)(void *)) free_FIX_TotalTakedown;
  SwigClassTotalTakedown.trackObjects = 0;
  
  SwigClassResponseDestination.klass = rb_define_class_under(mQuickfix, "ResponseDestination", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ResponseDestination, (void *) &SwigClassResponseDestination);
  rb_define_alloc_func(SwigClassResponseDestination.klass, _wrap_ResponseDestination_allocate);
  rb_define_method(SwigClassResponseDestination.klass, "initialize", VALUEFUNC(_wrap_new_ResponseDestination), -1);
  SwigClassResponseDestination.mark = 0;
  SwigClassResponseDestination.destroy = (void (*)(void *)) free_FIX_ResponseDestination;
  SwigClassResponseDestination.trackObjects = 0;
  
  SwigClassMDSecSizeType.klass = rb_define_class_under(mQuickfix, "MDSecSizeType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDSecSizeType, (void *) &SwigClassMDSecSizeType);
  rb_define_alloc_func(SwigClassMDSecSizeType.klass, _wrap_MDSecSizeType_allocate);
  rb_define_method(SwigClassMDSecSizeType.klass, "initialize", VALUEFUNC(_wrap_new_MDSecSizeType), -1);
  SwigClassMDSecSizeType.mark = 0;
  SwigClassMDSecSizeType.destroy = (void (*)(void *)) free_FIX_MDSecSizeType;
  SwigClassMDSecSizeType.trackObjects = 0;
  
  SwigClassInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "InstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartySubIDType, (void *) &SwigClassInstrumentPartySubIDType);
  rb_define_alloc_func(SwigClassInstrumentPartySubIDType.klass, _wrap_InstrumentPartySubIDType_allocate);
  rb_define_method(SwigClassInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartySubIDType), -1);
  SwigClassInstrumentPartySubIDType.mark = 0;
  SwigClassInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_InstrumentPartySubIDType;
  SwigClassInstrumentPartySubIDType.trackObjects = 0;
  
  SwigClassLegTimeUnit.klass = rb_define_class_under(mQuickfix, "LegTimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegTimeUnit, (void *) &SwigClassLegTimeUnit);
  rb_define_alloc_func(SwigClassLegTimeUnit.klass, _wrap_LegTimeUnit_allocate);
  rb_define_method(SwigClassLegTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_LegTimeUnit), -1);
  SwigClassLegTimeUnit.mark = 0;
  SwigClassLegTimeUnit.destroy = (void (*)(void *)) free_FIX_LegTimeUnit;
  SwigClassLegTimeUnit.trackObjects = 0;
  
  SwigClassTransferReason.klass = rb_define_class_under(mQuickfix, "TransferReason", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TransferReason, (void *) &SwigClassTransferReason);
  rb_define_alloc_func(SwigClassTransferReason.klass, _wrap_TransferReason_allocate);
  rb_define_method(SwigClassTransferReason.klass, "initialize", VALUEFUNC(_wrap_new_TransferReason), -1);
  SwigClassTransferReason.mark = 0;
  SwigClassTransferReason.destroy = (void (*)(void *)) free_FIX_TransferReason;
  SwigClassTransferReason.trackObjects = 0;
  
  SwigClassApplQueueMax.klass = rb_define_class_under(mQuickfix, "ApplQueueMax", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueMax, (void *) &SwigClassApplQueueMax);
  rb_define_alloc_func(SwigClassApplQueueMax.klass, _wrap_ApplQueueMax_allocate);
  rb_define_method(SwigClassApplQueueMax.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueMax), -1);
  SwigClassApplQueueMax.mark = 0;
  SwigClassApplQueueMax.destroy = (void (*)(void *)) free_FIX_ApplQueueMax;
  SwigClassApplQueueMax.trackObjects = 0;
  
  SwigClassDiscretionOffsetValue.klass = rb_define_class_under(mQuickfix, "DiscretionOffsetValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionOffsetValue, (void *) &SwigClassDiscretionOffsetValue);
  rb_define_alloc_func(SwigClassDiscretionOffsetValue.klass, _wrap_DiscretionOffsetValue_allocate);
  rb_define_method(SwigClassDiscretionOffsetValue.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionOffsetValue), -1);
  SwigClassDiscretionOffsetValue.mark = 0;
  SwigClassDiscretionOffsetValue.destroy = (void (*)(void *)) free_FIX_DiscretionOffsetValue;
  SwigClassDiscretionOffsetValue.trackObjects = 0;
  
  SwigClassBookingRefID.klass = rb_define_class_under(mQuickfix, "BookingRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BookingRefID, (void *) &SwigClassBookingRefID);
  rb_define_alloc_func(SwigClassBookingRefID.klass, _wrap_BookingRefID_allocate);
  rb_define_method(SwigClassBookingRefID.klass, "initialize", VALUEFUNC(_wrap_new_BookingRefID), -1);
  SwigClassBookingRefID.mark = 0;
  SwigClassBookingRefID.destroy = (void (*)(void *)) free_FIX_BookingRefID;
  SwigClassBookingRefID.trackObjects = 0;
  
  SwigClassLegBidPx.klass = rb_define_class_under(mQuickfix, "LegBidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBidPx, (void *) &SwigClassLegBidPx);
  rb_define_alloc_func(SwigClassLegBidPx.klass, _wrap_LegBidPx_allocate);
  rb_define_method(SwigClassLegBidPx.klass, "initialize", VALUEFUNC(_wrap_new_LegBidPx), -1);
  SwigClassLegBidPx.mark = 0;
  SwigClassLegBidPx.destroy = (void (*)(void *)) free_FIX_LegBidPx;
  SwigClassLegBidPx.trackObjects = 0;
  
  SwigClassTradSesEvent.klass = rb_define_class_under(mQuickfix, "TradSesEvent", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesEvent, (void *) &SwigClassTradSesEvent);
  rb_define_alloc_func(SwigClassTradSesEvent.klass, _wrap_TradSesEvent_allocate);
  rb_define_method(SwigClassTradSesEvent.klass, "initialize", VALUEFUNC(_wrap_new_TradSesEvent), -1);
  SwigClassTradSesEvent.mark = 0;
  SwigClassTradSesEvent.destroy = (void (*)(void *)) free_FIX_TradSesEvent;
  SwigClassTradSesEvent.trackObjects = 0;
  
  SwigClassDerivativeProduct.klass = rb_define_class_under(mQuickfix, "DerivativeProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeProduct, (void *) &SwigClassDerivativeProduct);
  rb_define_alloc_func(SwigClassDerivativeProduct.klass, _wrap_DerivativeProduct_allocate);
  rb_define_method(SwigClassDerivativeProduct.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeProduct), -1);
  SwigClassDerivativeProduct.mark = 0;
  SwigClassDerivativeProduct.destroy = (void (*)(void *)) free_FIX_DerivativeProduct;
  SwigClassDerivativeProduct.trackObjects = 0;
  
  SwigClassRootPartyRole.klass = rb_define_class_under(mQuickfix, "RootPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartyRole, (void *) &SwigClassRootPartyRole);
  rb_define_alloc_func(SwigClassRootPartyRole.klass, _wrap_RootPartyRole_allocate);
  rb_define_method(SwigClassRootPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_RootPartyRole), -1);
  SwigClassRootPartyRole.mark = 0;
  SwigClassRootPartyRole.destroy = (void (*)(void *)) free_FIX_RootPartyRole;
  SwigClassRootPartyRole.trackObjects = 0;
  
  SwigClassDlvyInstType.klass = rb_define_class_under(mQuickfix, "DlvyInstType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DlvyInstType, (void *) &SwigClassDlvyInstType);
  rb_define_alloc_func(SwigClassDlvyInstType.klass, _wrap_DlvyInstType_allocate);
  rb_define_method(SwigClassDlvyInstType.klass, "initialize", VALUEFUNC(_wrap_new_DlvyInstType), -1);
  SwigClassDlvyInstType.mark = 0;
  SwigClassDlvyInstType.destroy = (void (*)(void *)) free_FIX_DlvyInstType;
  SwigClassDlvyInstType.trackObjects = 0;
  
  SwigClassNoLinesOfText.klass = rb_define_class_under(mQuickfix, "NoLinesOfText", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLinesOfText, (void *) &SwigClassNoLinesOfText);
  rb_define_alloc_func(SwigClassNoLinesOfText.klass, _wrap_NoLinesOfText_allocate);
  rb_define_method(SwigClassNoLinesOfText.klass, "initialize", VALUEFUNC(_wrap_new_NoLinesOfText), -1);
  SwigClassNoLinesOfText.mark = 0;
  SwigClassNoLinesOfText.destroy = (void (*)(void *)) free_FIX_NoLinesOfText;
  SwigClassNoLinesOfText.trackObjects = 0;
  
  SwigClassPosReqID.klass = rb_define_class_under(mQuickfix, "PosReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqID, (void *) &SwigClassPosReqID);
  rb_define_alloc_func(SwigClassPosReqID.klass, _wrap_PosReqID_allocate);
  rb_define_method(SwigClassPosReqID.klass, "initialize", VALUEFUNC(_wrap_new_PosReqID), -1);
  SwigClassPosReqID.mark = 0;
  SwigClassPosReqID.destroy = (void (*)(void *)) free_FIX_PosReqID;
  SwigClassPosReqID.trackObjects = 0;
  
  SwigClassLegSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "LegSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityAltIDSource, (void *) &SwigClassLegSecurityAltIDSource);
  rb_define_alloc_func(SwigClassLegSecurityAltIDSource.klass, _wrap_LegSecurityAltIDSource_allocate);
  rb_define_method(SwigClassLegSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityAltIDSource), -1);
  SwigClassLegSecurityAltIDSource.mark = 0;
  SwigClassLegSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_LegSecurityAltIDSource;
  SwigClassLegSecurityAltIDSource.trackObjects = 0;
  
  SwigClassEncodedSubject.klass = rb_define_class_under(mQuickfix, "EncodedSubject", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSubject, (void *) &SwigClassEncodedSubject);
  rb_define_alloc_func(SwigClassEncodedSubject.klass, _wrap_EncodedSubject_allocate);
  rb_define_method(SwigClassEncodedSubject.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSubject), -1);
  SwigClassEncodedSubject.mark = 0;
  SwigClassEncodedSubject.destroy = (void (*)(void *)) free_FIX_EncodedSubject;
  SwigClassEncodedSubject.trackObjects = 0;
  
  SwigClassContraBroker.klass = rb_define_class_under(mQuickfix, "ContraBroker", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraBroker, (void *) &SwigClassContraBroker);
  rb_define_alloc_func(SwigClassContraBroker.klass, _wrap_ContraBroker_allocate);
  rb_define_method(SwigClassContraBroker.klass, "initialize", VALUEFUNC(_wrap_new_ContraBroker), -1);
  SwigClassContraBroker.mark = 0;
  SwigClassContraBroker.destroy = (void (*)(void *)) free_FIX_ContraBroker;
  SwigClassContraBroker.trackObjects = 0;
  
  SwigClassTradeCondition.klass = rb_define_class_under(mQuickfix, "TradeCondition", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeCondition, (void *) &SwigClassTradeCondition);
  rb_define_alloc_func(SwigClassTradeCondition.klass, _wrap_TradeCondition_allocate);
  rb_define_method(SwigClassTradeCondition.klass, "initialize", VALUEFUNC(_wrap_new_TradeCondition), -1);
  SwigClassTradeCondition.mark = 0;
  SwigClassTradeCondition.destroy = (void (*)(void *)) free_FIX_TradeCondition;
  SwigClassTradeCondition.trackObjects = 0;
  
  SwigClassPartyID.klass = rb_define_class_under(mQuickfix, "PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyID, (void *) &SwigClassPartyID);
  rb_define_alloc_func(SwigClassPartyID.klass, _wrap_PartyID_allocate);
  rb_define_method(SwigClassPartyID.klass, "initialize", VALUEFUNC(_wrap_new_PartyID), -1);
  SwigClassPartyID.mark = 0;
  SwigClassPartyID.destroy = (void (*)(void *)) free_FIX_PartyID;
  SwigClassPartyID.trackObjects = 0;
  
  SwigClassMDEntryID.klass = rb_define_class_under(mQuickfix, "MDEntryID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryID, (void *) &SwigClassMDEntryID);
  rb_define_alloc_func(SwigClassMDEntryID.klass, _wrap_MDEntryID_allocate);
  rb_define_method(SwigClassMDEntryID.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryID), -1);
  SwigClassMDEntryID.mark = 0;
  SwigClassMDEntryID.destroy = (void (*)(void *)) free_FIX_MDEntryID;
  SwigClassMDEntryID.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityExchange.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange, (void *) &SwigClassUnderlyingLegSecurityExchange);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityExchange.klass, _wrap_UnderlyingLegSecurityExchange_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityExchange), -1);
  SwigClassUnderlyingLegSecurityExchange.mark = 0;
  SwigClassUnderlyingLegSecurityExchange.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityExchange;
  SwigClassUnderlyingLegSecurityExchange.trackObjects = 0;
  
  SwigClassPriceLimitType.klass = rb_define_class_under(mQuickfix, "PriceLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceLimitType, (void *) &SwigClassPriceLimitType);
  rb_define_alloc_func(SwigClassPriceLimitType.klass, _wrap_PriceLimitType_allocate);
  rb_define_method(SwigClassPriceLimitType.klass, "initialize", VALUEFUNC(_wrap_new_PriceLimitType), -1);
  SwigClassPriceLimitType.mark = 0;
  SwigClassPriceLimitType.destroy = (void (*)(void *)) free_FIX_PriceLimitType;
  SwigClassPriceLimitType.trackObjects = 0;
  
  SwigClassTriggerSecurityIDSource.klass = rb_define_class_under(mQuickfix, "TriggerSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSecurityIDSource, (void *) &SwigClassTriggerSecurityIDSource);
  rb_define_alloc_func(SwigClassTriggerSecurityIDSource.klass, _wrap_TriggerSecurityIDSource_allocate);
  rb_define_method(SwigClassTriggerSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSecurityIDSource), -1);
  SwigClassTriggerSecurityIDSource.mark = 0;
  SwigClassTriggerSecurityIDSource.destroy = (void (*)(void *)) free_FIX_TriggerSecurityIDSource;
  SwigClassTriggerSecurityIDSource.trackObjects = 0;
  
  SwigClassNoUndlyInstrumentPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoUndlyInstrumentPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs, (void *) &SwigClassNoUndlyInstrumentPartySubIDs);
  rb_define_alloc_func(SwigClassNoUndlyInstrumentPartySubIDs.klass, _wrap_NoUndlyInstrumentPartySubIDs_allocate);
  rb_define_method(SwigClassNoUndlyInstrumentPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoUndlyInstrumentPartySubIDs), -1);
  SwigClassNoUndlyInstrumentPartySubIDs.mark = 0;
  SwigClassNoUndlyInstrumentPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoUndlyInstrumentPartySubIDs;
  SwigClassNoUndlyInstrumentPartySubIDs.trackObjects = 0;
  
  SwigClassClientBidID.klass = rb_define_class_under(mQuickfix, "ClientBidID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClientBidID, (void *) &SwigClassClientBidID);
  rb_define_alloc_func(SwigClassClientBidID.klass, _wrap_ClientBidID_allocate);
  rb_define_method(SwigClassClientBidID.klass, "initialize", VALUEFUNC(_wrap_new_ClientBidID), -1);
  SwigClassClientBidID.mark = 0;
  SwigClassClientBidID.destroy = (void (*)(void *)) free_FIX_ClientBidID;
  SwigClassClientBidID.trackObjects = 0;
  
  SwigClassNetChgPrevDay.klass = rb_define_class_under(mQuickfix, "NetChgPrevDay", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetChgPrevDay, (void *) &SwigClassNetChgPrevDay);
  rb_define_alloc_func(SwigClassNetChgPrevDay.klass, _wrap_NetChgPrevDay_allocate);
  rb_define_method(SwigClassNetChgPrevDay.klass, "initialize", VALUEFUNC(_wrap_new_NetChgPrevDay), -1);
  SwigClassNetChgPrevDay.mark = 0;
  SwigClassNetChgPrevDay.destroy = (void (*)(void *)) free_FIX_NetChgPrevDay;
  SwigClassNetChgPrevDay.trackObjects = 0;
  
  SwigClassDefaultApplVerID.klass = rb_define_class_under(mQuickfix, "DefaultApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultApplVerID, (void *) &SwigClassDefaultApplVerID);
  rb_define_alloc_func(SwigClassDefaultApplVerID.klass, _wrap_DefaultApplVerID_allocate);
  rb_define_method(SwigClassDefaultApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_DefaultApplVerID), -1);
  SwigClassDefaultApplVerID.mark = 0;
  SwigClassDefaultApplVerID.destroy = (void (*)(void *)) free_FIX_DefaultApplVerID;
  SwigClassDefaultApplVerID.trackObjects = 0;
  
  SwigClassIOIID.klass = rb_define_class_under(mQuickfix, "IOIID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIID, (void *) &SwigClassIOIID);
  rb_define_alloc_func(SwigClassIOIID.klass, _wrap_IOIID_allocate);
  rb_define_method(SwigClassIOIID.klass, "initialize", VALUEFUNC(_wrap_new_IOIID), -1);
  SwigClassIOIID.mark = 0;
  SwigClassIOIID.destroy = (void (*)(void *)) free_FIX_IOIID;
  SwigClassIOIID.trackObjects = 0;
  
  SwigClassSpreadToBenchmark.klass = rb_define_class_under(mQuickfix, "SpreadToBenchmark", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SpreadToBenchmark, (void *) &SwigClassSpreadToBenchmark);
  rb_define_alloc_func(SwigClassSpreadToBenchmark.klass, _wrap_SpreadToBenchmark_allocate);
  rb_define_method(SwigClassSpreadToBenchmark.klass, "initialize", VALUEFUNC(_wrap_new_SpreadToBenchmark), -1);
  SwigClassSpreadToBenchmark.mark = 0;
  SwigClassSpreadToBenchmark.destroy = (void (*)(void *)) free_FIX_SpreadToBenchmark;
  SwigClassSpreadToBenchmark.trackObjects = 0;
  
  SwigClassCommType.klass = rb_define_class_under(mQuickfix, "CommType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CommType, (void *) &SwigClassCommType);
  rb_define_alloc_func(SwigClassCommType.klass, _wrap_CommType_allocate);
  rb_define_method(SwigClassCommType.klass, "initialize", VALUEFUNC(_wrap_new_CommType), -1);
  SwigClassCommType.mark = 0;
  SwigClassCommType.destroy = (void (*)(void *)) free_FIX_CommType;
  SwigClassCommType.trackObjects = 0;
  
  SwigClassRegistRejReasonCode.klass = rb_define_class_under(mQuickfix, "RegistRejReasonCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistRejReasonCode, (void *) &SwigClassRegistRejReasonCode);
  rb_define_alloc_func(SwigClassRegistRejReasonCode.klass, _wrap_RegistRejReasonCode_allocate);
  rb_define_method(SwigClassRegistRejReasonCode.klass, "initialize", VALUEFUNC(_wrap_new_RegistRejReasonCode), -1);
  SwigClassRegistRejReasonCode.mark = 0;
  SwigClassRegistRejReasonCode.destroy = (void (*)(void *)) free_FIX_RegistRejReasonCode;
  SwigClassRegistRejReasonCode.trackObjects = 0;
  
  SwigClassSideTimeInForce.klass = rb_define_class_under(mQuickfix, "SideTimeInForce", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTimeInForce, (void *) &SwigClassSideTimeInForce);
  rb_define_alloc_func(SwigClassSideTimeInForce.klass, _wrap_SideTimeInForce_allocate);
  rb_define_method(SwigClassSideTimeInForce.klass, "initialize", VALUEFUNC(_wrap_new_SideTimeInForce), -1);
  SwigClassSideTimeInForce.mark = 0;
  SwigClassSideTimeInForce.destroy = (void (*)(void *)) free_FIX_SideTimeInForce;
  SwigClassSideTimeInForce.trackObjects = 0;
  
  SwigClassTrdRegTimestamp.klass = rb_define_class_under(mQuickfix, "TrdRegTimestamp", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRegTimestamp, (void *) &SwigClassTrdRegTimestamp);
  rb_define_alloc_func(SwigClassTrdRegTimestamp.klass, _wrap_TrdRegTimestamp_allocate);
  rb_define_method(SwigClassTrdRegTimestamp.klass, "initialize", VALUEFUNC(_wrap_new_TrdRegTimestamp), -1);
  SwigClassTrdRegTimestamp.mark = 0;
  SwigClassTrdRegTimestamp.destroy = (void (*)(void *)) free_FIX_TrdRegTimestamp;
  SwigClassTrdRegTimestamp.trackObjects = 0;
  
  SwigClassFinancialStatus.klass = rb_define_class_under(mQuickfix, "FinancialStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FinancialStatus, (void *) &SwigClassFinancialStatus);
  rb_define_alloc_func(SwigClassFinancialStatus.klass, _wrap_FinancialStatus_allocate);
  rb_define_method(SwigClassFinancialStatus.klass, "initialize", VALUEFUNC(_wrap_new_FinancialStatus), -1);
  SwigClassFinancialStatus.mark = 0;
  SwigClassFinancialStatus.destroy = (void (*)(void *)) free_FIX_FinancialStatus;
  SwigClassFinancialStatus.trackObjects = 0;
  
  SwigClassNoTrades.klass = rb_define_class_under(mQuickfix, "NoTrades", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTrades, (void *) &SwigClassNoTrades);
  rb_define_alloc_func(SwigClassNoTrades.klass, _wrap_NoTrades_allocate);
  rb_define_method(SwigClassNoTrades.klass, "initialize", VALUEFUNC(_wrap_new_NoTrades), -1);
  SwigClassNoTrades.mark = 0;
  SwigClassNoTrades.destroy = (void (*)(void *)) free_FIX_NoTrades;
  SwigClassNoTrades.trackObjects = 0;
  
  SwigClassLastFragment.klass = rb_define_class_under(mQuickfix, "LastFragment", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastFragment, (void *) &SwigClassLastFragment);
  rb_define_alloc_func(SwigClassLastFragment.klass, _wrap_LastFragment_allocate);
  rb_define_method(SwigClassLastFragment.klass, "initialize", VALUEFUNC(_wrap_new_LastFragment), -1);
  SwigClassLastFragment.mark = 0;
  SwigClassLastFragment.destroy = (void (*)(void *)) free_FIX_LastFragment;
  SwigClassLastFragment.trackObjects = 0;
  
  SwigClassPartySubID.klass = rb_define_class_under(mQuickfix, "PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartySubID, (void *) &SwigClassPartySubID);
  rb_define_alloc_func(SwigClassPartySubID.klass, _wrap_PartySubID_allocate);
  rb_define_method(SwigClassPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_PartySubID), -1);
  SwigClassPartySubID.mark = 0;
  SwigClassPartySubID.destroy = (void (*)(void *)) free_FIX_PartySubID;
  SwigClassPartySubID.trackObjects = 0;
  
  SwigClassAllocQty.klass = rb_define_class_under(mQuickfix, "AllocQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocQty, (void *) &SwigClassAllocQty);
  rb_define_alloc_func(SwigClassAllocQty.klass, _wrap_AllocQty_allocate);
  rb_define_method(SwigClassAllocQty.klass, "initialize", VALUEFUNC(_wrap_new_AllocQty), -1);
  SwigClassAllocQty.mark = 0;
  SwigClassAllocQty.destroy = (void (*)(void *)) free_FIX_AllocQty;
  SwigClassAllocQty.trackObjects = 0;
  
  SwigClassNotifyBrokerOfCredit.klass = rb_define_class_under(mQuickfix, "NotifyBrokerOfCredit", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotifyBrokerOfCredit, (void *) &SwigClassNotifyBrokerOfCredit);
  rb_define_alloc_func(SwigClassNotifyBrokerOfCredit.klass, _wrap_NotifyBrokerOfCredit_allocate);
  rb_define_method(SwigClassNotifyBrokerOfCredit.klass, "initialize", VALUEFUNC(_wrap_new_NotifyBrokerOfCredit), -1);
  SwigClassNotifyBrokerOfCredit.mark = 0;
  SwigClassNotifyBrokerOfCredit.destroy = (void (*)(void *)) free_FIX_NotifyBrokerOfCredit;
  SwigClassNotifyBrokerOfCredit.trackObjects = 0;
  
  SwigClassSideTrdRegTimestampType.klass = rb_define_class_under(mQuickfix, "SideTrdRegTimestampType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdRegTimestampType, (void *) &SwigClassSideTrdRegTimestampType);
  rb_define_alloc_func(SwigClassSideTrdRegTimestampType.klass, _wrap_SideTrdRegTimestampType_allocate);
  rb_define_method(SwigClassSideTrdRegTimestampType.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdRegTimestampType), -1);
  SwigClassSideTrdRegTimestampType.mark = 0;
  SwigClassSideTrdRegTimestampType.destroy = (void (*)(void *)) free_FIX_SideTrdRegTimestampType;
  SwigClassSideTrdRegTimestampType.trackObjects = 0;
  
  SwigClassAgreementDate.klass = rb_define_class_under(mQuickfix, "AgreementDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementDate, (void *) &SwigClassAgreementDate);
  rb_define_alloc_func(SwigClassAgreementDate.klass, _wrap_AgreementDate_allocate);
  rb_define_method(SwigClassAgreementDate.klass, "initialize", VALUEFUNC(_wrap_new_AgreementDate), -1);
  SwigClassAgreementDate.mark = 0;
  SwigClassAgreementDate.destroy = (void (*)(void *)) free_FIX_AgreementDate;
  SwigClassAgreementDate.trackObjects = 0;
  
  SwigClassPartySubIDType.klass = rb_define_class_under(mQuickfix, "PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartySubIDType, (void *) &SwigClassPartySubIDType);
  rb_define_alloc_func(SwigClassPartySubIDType.klass, _wrap_PartySubIDType_allocate);
  rb_define_method(SwigClassPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_PartySubIDType), -1);
  SwigClassPartySubIDType.mark = 0;
  SwigClassPartySubIDType.destroy = (void (*)(void *)) free_FIX_PartySubIDType;
  SwigClassPartySubIDType.trackObjects = 0;
  
  SwigClassTotalNetValue.klass = rb_define_class_under(mQuickfix, "TotalNetValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNetValue, (void *) &SwigClassTotalNetValue);
  rb_define_alloc_func(SwigClassTotalNetValue.klass, _wrap_TotalNetValue_allocate);
  rb_define_method(SwigClassTotalNetValue.klass, "initialize", VALUEFUNC(_wrap_new_TotalNetValue), -1);
  SwigClassTotalNetValue.mark = 0;
  SwigClassTotalNetValue.destroy = (void (*)(void *)) free_FIX_TotalNetValue;
  SwigClassTotalNetValue.trackObjects = 0;
  
  SwigClassAllocNoOrdersType.klass = rb_define_class_under(mQuickfix, "AllocNoOrdersType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocNoOrdersType, (void *) &SwigClassAllocNoOrdersType);
  rb_define_alloc_func(SwigClassAllocNoOrdersType.klass, _wrap_AllocNoOrdersType_allocate);
  rb_define_method(SwigClassAllocNoOrdersType.klass, "initialize", VALUEFUNC(_wrap_new_AllocNoOrdersType), -1);
  SwigClassAllocNoOrdersType.mark = 0;
  SwigClassAllocNoOrdersType.destroy = (void (*)(void *)) free_FIX_AllocNoOrdersType;
  SwigClassAllocNoOrdersType.trackObjects = 0;
  
  SwigClassAllocLinkID.klass = rb_define_class_under(mQuickfix, "AllocLinkID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocLinkID, (void *) &SwigClassAllocLinkID);
  rb_define_alloc_func(SwigClassAllocLinkID.klass, _wrap_AllocLinkID_allocate);
  rb_define_method(SwigClassAllocLinkID.klass, "initialize", VALUEFUNC(_wrap_new_AllocLinkID), -1);
  SwigClassAllocLinkID.mark = 0;
  SwigClassAllocLinkID.destroy = (void (*)(void *)) free_FIX_AllocLinkID;
  SwigClassAllocLinkID.trackObjects = 0;
  
  SwigClassRoundingModulus.klass = rb_define_class_under(mQuickfix, "RoundingModulus", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoundingModulus, (void *) &SwigClassRoundingModulus);
  rb_define_alloc_func(SwigClassRoundingModulus.klass, _wrap_RoundingModulus_allocate);
  rb_define_method(SwigClassRoundingModulus.klass, "initialize", VALUEFUNC(_wrap_new_RoundingModulus), -1);
  SwigClassRoundingModulus.mark = 0;
  SwigClassRoundingModulus.destroy = (void (*)(void *)) free_FIX_RoundingModulus;
  SwigClassRoundingModulus.trackObjects = 0;
  
  SwigClassOnBehalfOfCompID.klass = rb_define_class_under(mQuickfix, "OnBehalfOfCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfCompID, (void *) &SwigClassOnBehalfOfCompID);
  rb_define_alloc_func(SwigClassOnBehalfOfCompID.klass, _wrap_OnBehalfOfCompID_allocate);
  rb_define_method(SwigClassOnBehalfOfCompID.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfCompID), -1);
  SwigClassOnBehalfOfCompID.mark = 0;
  SwigClassOnBehalfOfCompID.destroy = (void (*)(void *)) free_FIX_OnBehalfOfCompID;
  SwigClassOnBehalfOfCompID.trackObjects = 0;
  
  SwigClassUnderlyingSecurityID.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityID, (void *) &SwigClassUnderlyingSecurityID);
  rb_define_alloc_func(SwigClassUnderlyingSecurityID.klass, _wrap_UnderlyingSecurityID_allocate);
  rb_define_method(SwigClassUnderlyingSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityID), -1);
  SwigClassUnderlyingSecurityID.mark = 0;
  SwigClassUnderlyingSecurityID.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityID;
  SwigClassUnderlyingSecurityID.trackObjects = 0;
  
  SwigClassSettlObligMsgID.klass = rb_define_class_under(mQuickfix, "SettlObligMsgID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligMsgID, (void *) &SwigClassSettlObligMsgID);
  rb_define_alloc_func(SwigClassSettlObligMsgID.klass, _wrap_SettlObligMsgID_allocate);
  rb_define_method(SwigClassSettlObligMsgID.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligMsgID), -1);
  SwigClassSettlObligMsgID.mark = 0;
  SwigClassSettlObligMsgID.destroy = (void (*)(void *)) free_FIX_SettlObligMsgID;
  SwigClassSettlObligMsgID.trackObjects = 0;
  
  SwigClassPositionLimit.klass = rb_define_class_under(mQuickfix, "PositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PositionLimit, (void *) &SwigClassPositionLimit);
  rb_define_alloc_func(SwigClassPositionLimit.klass, _wrap_PositionLimit_allocate);
  rb_define_method(SwigClassPositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_PositionLimit), -1);
  SwigClassPositionLimit.mark = 0;
  SwigClassPositionLimit.destroy = (void (*)(void *)) free_FIX_PositionLimit;
  SwigClassPositionLimit.trackObjects = 0;
  
  SwigClassSharedCommission.klass = rb_define_class_under(mQuickfix, "SharedCommission", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SharedCommission, (void *) &SwigClassSharedCommission);
  rb_define_alloc_func(SwigClassSharedCommission.klass, _wrap_SharedCommission_allocate);
  rb_define_method(SwigClassSharedCommission.klass, "initialize", VALUEFUNC(_wrap_new_SharedCommission), -1);
  SwigClassSharedCommission.mark = 0;
  SwigClassSharedCommission.destroy = (void (*)(void *)) free_FIX_SharedCommission;
  SwigClassSharedCommission.trackObjects = 0;
  
  SwigClassAllowableOneSidednessPct.klass = rb_define_class_under(mQuickfix, "AllowableOneSidednessPct", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllowableOneSidednessPct, (void *) &SwigClassAllowableOneSidednessPct);
  rb_define_alloc_func(SwigClassAllowableOneSidednessPct.klass, _wrap_AllowableOneSidednessPct_allocate);
  rb_define_method(SwigClassAllowableOneSidednessPct.klass, "initialize", VALUEFUNC(_wrap_new_AllowableOneSidednessPct), -1);
  SwigClassAllowableOneSidednessPct.mark = 0;
  SwigClassAllowableOneSidednessPct.destroy = (void (*)(void *)) free_FIX_AllowableOneSidednessPct;
  SwigClassAllowableOneSidednessPct.trackObjects = 0;
  
  SwigClassAllocText.klass = rb_define_class_under(mQuickfix, "AllocText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocText, (void *) &SwigClassAllocText);
  rb_define_alloc_func(SwigClassAllocText.klass, _wrap_AllocText_allocate);
  rb_define_method(SwigClassAllocText.klass, "initialize", VALUEFUNC(_wrap_new_AllocText), -1);
  SwigClassAllocText.mark = 0;
  SwigClassAllocText.destroy = (void (*)(void *)) free_FIX_AllocText;
  SwigClassAllocText.trackObjects = 0;
  
  SwigClassEndSeqNo.klass = rb_define_class_under(mQuickfix, "EndSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndSeqNo, (void *) &SwigClassEndSeqNo);
  rb_define_alloc_func(SwigClassEndSeqNo.klass, _wrap_EndSeqNo_allocate);
  rb_define_method(SwigClassEndSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_EndSeqNo), -1);
  SwigClassEndSeqNo.mark = 0;
  SwigClassEndSeqNo.destroy = (void (*)(void *)) free_FIX_EndSeqNo;
  SwigClassEndSeqNo.trackObjects = 0;
  
  SwigClassNoPartyIDs.klass = rb_define_class_under(mQuickfix, "NoPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyIDs, (void *) &SwigClassNoPartyIDs);
  rb_define_alloc_func(SwigClassNoPartyIDs.klass, _wrap_NoPartyIDs_allocate);
  rb_define_method(SwigClassNoPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyIDs), -1);
  SwigClassNoPartyIDs.mark = 0;
  SwigClassNoPartyIDs.destroy = (void (*)(void *)) free_FIX_NoPartyIDs;
  SwigClassNoPartyIDs.trackObjects = 0;
  
  SwigClassNoContraBrokers.klass = rb_define_class_under(mQuickfix, "NoContraBrokers", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoContraBrokers, (void *) &SwigClassNoContraBrokers);
  rb_define_alloc_func(SwigClassNoContraBrokers.klass, _wrap_NoContraBrokers_allocate);
  rb_define_method(SwigClassNoContraBrokers.klass, "initialize", VALUEFUNC(_wrap_new_NoContraBrokers), -1);
  SwigClassNoContraBrokers.mark = 0;
  SwigClassNoContraBrokers.destroy = (void (*)(void *)) free_FIX_NoContraBrokers;
  SwigClassNoContraBrokers.trackObjects = 0;
  
  SwigClassAllocLinkType.klass = rb_define_class_under(mQuickfix, "AllocLinkType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocLinkType, (void *) &SwigClassAllocLinkType);
  rb_define_alloc_func(SwigClassAllocLinkType.klass, _wrap_AllocLinkType_allocate);
  rb_define_method(SwigClassAllocLinkType.klass, "initialize", VALUEFUNC(_wrap_new_AllocLinkType), -1);
  SwigClassAllocLinkType.mark = 0;
  SwigClassAllocLinkType.destroy = (void (*)(void *)) free_FIX_AllocLinkType;
  SwigClassAllocLinkType.trackObjects = 0;
  
  SwigClassUnderlyingAllocationPercent.klass = rb_define_class_under(mQuickfix, "UnderlyingAllocationPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingAllocationPercent, (void *) &SwigClassUnderlyingAllocationPercent);
  rb_define_alloc_func(SwigClassUnderlyingAllocationPercent.klass, _wrap_UnderlyingAllocationPercent_allocate);
  rb_define_method(SwigClassUnderlyingAllocationPercent.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingAllocationPercent), -1);
  SwigClassUnderlyingAllocationPercent.mark = 0;
  SwigClassUnderlyingAllocationPercent.destroy = (void (*)(void *)) free_FIX_UnderlyingAllocationPercent;
  SwigClassUnderlyingAllocationPercent.trackObjects = 0;
  
  SwigClassAllocAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "AllocAccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAccruedInterestAmt, (void *) &SwigClassAllocAccruedInterestAmt);
  rb_define_alloc_func(SwigClassAllocAccruedInterestAmt.klass, _wrap_AllocAccruedInterestAmt_allocate);
  rb_define_method(SwigClassAllocAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_AllocAccruedInterestAmt), -1);
  SwigClassAllocAccruedInterestAmt.mark = 0;
  SwigClassAllocAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_AllocAccruedInterestAmt;
  SwigClassAllocAccruedInterestAmt.trackObjects = 0;
  
  SwigClassEncodedSecurityListDesc.klass = rb_define_class_under(mQuickfix, "EncodedSecurityListDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityListDesc, (void *) &SwigClassEncodedSecurityListDesc);
  rb_define_alloc_func(SwigClassEncodedSecurityListDesc.klass, _wrap_EncodedSecurityListDesc_allocate);
  rb_define_method(SwigClassEncodedSecurityListDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityListDesc), -1);
  SwigClassEncodedSecurityListDesc.mark = 0;
  SwigClassEncodedSecurityListDesc.destroy = (void (*)(void *)) free_FIX_EncodedSecurityListDesc;
  SwigClassEncodedSecurityListDesc.trackObjects = 0;
  
  SwigClassEncryptedPasswordLen.klass = rb_define_class_under(mQuickfix, "EncryptedPasswordLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedPasswordLen, (void *) &SwigClassEncryptedPasswordLen);
  rb_define_alloc_func(SwigClassEncryptedPasswordLen.klass, _wrap_EncryptedPasswordLen_allocate);
  rb_define_method(SwigClassEncryptedPasswordLen.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedPasswordLen), -1);
  SwigClassEncryptedPasswordLen.mark = 0;
  SwigClassEncryptedPasswordLen.destroy = (void (*)(void *)) free_FIX_EncryptedPasswordLen;
  SwigClassEncryptedPasswordLen.trackObjects = 0;
  
  SwigClassLegDividendYield.klass = rb_define_class_under(mQuickfix, "LegDividendYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegDividendYield, (void *) &SwigClassLegDividendYield);
  rb_define_alloc_func(SwigClassLegDividendYield.klass, _wrap_LegDividendYield_allocate);
  rb_define_method(SwigClassLegDividendYield.klass, "initialize", VALUEFUNC(_wrap_new_LegDividendYield), -1);
  SwigClassLegDividendYield.mark = 0;
  SwigClassLegDividendYield.destroy = (void (*)(void *)) free_FIX_LegDividendYield;
  SwigClassLegDividendYield.trackObjects = 0;
  
  SwigClassRefreshIndicator.klass = rb_define_class_under(mQuickfix, "RefreshIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefreshIndicator, (void *) &SwigClassRefreshIndicator);
  rb_define_alloc_func(SwigClassRefreshIndicator.klass, _wrap_RefreshIndicator_allocate);
  rb_define_method(SwigClassRefreshIndicator.klass, "initialize", VALUEFUNC(_wrap_new_RefreshIndicator), -1);
  SwigClassRefreshIndicator.mark = 0;
  SwigClassRefreshIndicator.destroy = (void (*)(void *)) free_FIX_RefreshIndicator;
  SwigClassRefreshIndicator.trackObjects = 0;
  
  SwigClassSideSettlCurrency.klass = rb_define_class_under(mQuickfix, "SideSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideSettlCurrency, (void *) &SwigClassSideSettlCurrency);
  rb_define_alloc_func(SwigClassSideSettlCurrency.klass, _wrap_SideSettlCurrency_allocate);
  rb_define_method(SwigClassSideSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_SideSettlCurrency), -1);
  SwigClassSideSettlCurrency.mark = 0;
  SwigClassSideSettlCurrency.destroy = (void (*)(void *)) free_FIX_SideSettlCurrency;
  SwigClassSideSettlCurrency.trackObjects = 0;
  
  SwigClassUnderlyingSettlementType.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlementType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlementType, (void *) &SwigClassUnderlyingSettlementType);
  rb_define_alloc_func(SwigClassUnderlyingSettlementType.klass, _wrap_UnderlyingSettlementType_allocate);
  rb_define_method(SwigClassUnderlyingSettlementType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlementType), -1);
  SwigClassUnderlyingSettlementType.mark = 0;
  SwigClassUnderlyingSettlementType.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlementType;
  SwigClassUnderlyingSettlementType.trackObjects = 0;
  
  SwigClassOrderCapacityQty.klass = rb_define_class_under(mQuickfix, "OrderCapacityQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderCapacityQty, (void *) &SwigClassOrderCapacityQty);
  rb_define_alloc_func(SwigClassOrderCapacityQty.klass, _wrap_OrderCapacityQty_allocate);
  rb_define_method(SwigClassOrderCapacityQty.klass, "initialize", VALUEFUNC(_wrap_new_OrderCapacityQty), -1);
  SwigClassOrderCapacityQty.mark = 0;
  SwigClassOrderCapacityQty.destroy = (void (*)(void *)) free_FIX_OrderCapacityQty;
  SwigClassOrderCapacityQty.trackObjects = 0;
  
  SwigClassLongQty.klass = rb_define_class_under(mQuickfix, "LongQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LongQty, (void *) &SwigClassLongQty);
  rb_define_alloc_func(SwigClassLongQty.klass, _wrap_LongQty_allocate);
  rb_define_method(SwigClassLongQty.klass, "initialize", VALUEFUNC(_wrap_new_LongQty), -1);
  SwigClassLongQty.mark = 0;
  SwigClassLongQty.destroy = (void (*)(void *)) free_FIX_LongQty;
  SwigClassLongQty.trackObjects = 0;
  
  SwigClassDerivativeSettlMethod.klass = rb_define_class_under(mQuickfix, "DerivativeSettlMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSettlMethod, (void *) &SwigClassDerivativeSettlMethod);
  rb_define_alloc_func(SwigClassDerivativeSettlMethod.klass, _wrap_DerivativeSettlMethod_allocate);
  rb_define_method(SwigClassDerivativeSettlMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSettlMethod), -1);
  SwigClassDerivativeSettlMethod.mark = 0;
  SwigClassDerivativeSettlMethod.destroy = (void (*)(void *)) free_FIX_DerivativeSettlMethod;
  SwigClassDerivativeSettlMethod.trackObjects = 0;
  
  SwigClassTriggerTradingSessionID.klass = rb_define_class_under(mQuickfix, "TriggerTradingSessionID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerTradingSessionID, (void *) &SwigClassTriggerTradingSessionID);
  rb_define_alloc_func(SwigClassTriggerTradingSessionID.klass, _wrap_TriggerTradingSessionID_allocate);
  rb_define_method(SwigClassTriggerTradingSessionID.klass, "initialize", VALUEFUNC(_wrap_new_TriggerTradingSessionID), -1);
  SwigClassTriggerTradingSessionID.mark = 0;
  SwigClassTriggerTradingSessionID.destroy = (void (*)(void *)) free_FIX_TriggerTradingSessionID;
  SwigClassTriggerTradingSessionID.trackObjects = 0;
  
  SwigClassDisplayMethod.klass = rb_define_class_under(mQuickfix, "DisplayMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayMethod, (void *) &SwigClassDisplayMethod);
  rb_define_alloc_func(SwigClassDisplayMethod.klass, _wrap_DisplayMethod_allocate);
  rb_define_method(SwigClassDisplayMethod.klass, "initialize", VALUEFUNC(_wrap_new_DisplayMethod), -1);
  SwigClassDisplayMethod.mark = 0;
  SwigClassDisplayMethod.destroy = (void (*)(void *)) free_FIX_DisplayMethod;
  SwigClassDisplayMethod.trackObjects = 0;
  
  SwigClassRptSeq.klass = rb_define_class_under(mQuickfix, "RptSeq", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RptSeq, (void *) &SwigClassRptSeq);
  rb_define_alloc_func(SwigClassRptSeq.klass, _wrap_RptSeq_allocate);
  rb_define_method(SwigClassRptSeq.klass, "initialize", VALUEFUNC(_wrap_new_RptSeq), -1);
  SwigClassRptSeq.mark = 0;
  SwigClassRptSeq.destroy = (void (*)(void *)) free_FIX_RptSeq;
  SwigClassRptSeq.trackObjects = 0;
  
  SwigClassMDEntryOriginator.klass = rb_define_class_under(mQuickfix, "MDEntryOriginator", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryOriginator, (void *) &SwigClassMDEntryOriginator);
  rb_define_alloc_func(SwigClassMDEntryOriginator.klass, _wrap_MDEntryOriginator_allocate);
  rb_define_method(SwigClassMDEntryOriginator.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryOriginator), -1);
  SwigClassMDEntryOriginator.mark = 0;
  SwigClassMDEntryOriginator.destroy = (void (*)(void *)) free_FIX_MDEntryOriginator;
  SwigClassMDEntryOriginator.trackObjects = 0;
  
  SwigClassLegInstrRegistry.klass = rb_define_class_under(mQuickfix, "LegInstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegInstrRegistry, (void *) &SwigClassLegInstrRegistry);
  rb_define_alloc_func(SwigClassLegInstrRegistry.klass, _wrap_LegInstrRegistry_allocate);
  rb_define_method(SwigClassLegInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_LegInstrRegistry), -1);
  SwigClassLegInstrRegistry.mark = 0;
  SwigClassLegInstrRegistry.destroy = (void (*)(void *)) free_FIX_LegInstrRegistry;
  SwigClassLegInstrRegistry.trackObjects = 0;
  
  SwigClassFillQty.klass = rb_define_class_under(mQuickfix, "FillQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillQty, (void *) &SwigClassFillQty);
  rb_define_alloc_func(SwigClassFillQty.klass, _wrap_FillQty_allocate);
  rb_define_method(SwigClassFillQty.klass, "initialize", VALUEFUNC(_wrap_new_FillQty), -1);
  SwigClassFillQty.mark = 0;
  SwigClassFillQty.destroy = (void (*)(void *)) free_FIX_FillQty;
  SwigClassFillQty.trackObjects = 0;
  
  SwigClassPegSecurityIDSource.klass = rb_define_class_under(mQuickfix, "PegSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSecurityIDSource, (void *) &SwigClassPegSecurityIDSource);
  rb_define_alloc_func(SwigClassPegSecurityIDSource.klass, _wrap_PegSecurityIDSource_allocate);
  rb_define_method(SwigClassPegSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_PegSecurityIDSource), -1);
  SwigClassPegSecurityIDSource.mark = 0;
  SwigClassPegSecurityIDSource.destroy = (void (*)(void *)) free_FIX_PegSecurityIDSource;
  SwigClassPegSecurityIDSource.trackObjects = 0;
  
  SwigClassMaturityTime.klass = rb_define_class_under(mQuickfix, "MaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityTime, (void *) &SwigClassMaturityTime);
  rb_define_alloc_func(SwigClassMaturityTime.klass, _wrap_MaturityTime_allocate);
  rb_define_method(SwigClassMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_MaturityTime), -1);
  SwigClassMaturityTime.mark = 0;
  SwigClassMaturityTime.destroy = (void (*)(void *)) free_FIX_MaturityTime;
  SwigClassMaturityTime.trackObjects = 0;
  
  SwigClassMDFeedType.klass = rb_define_class_under(mQuickfix, "MDFeedType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDFeedType, (void *) &SwigClassMDFeedType);
  rb_define_alloc_func(SwigClassMDFeedType.klass, _wrap_MDFeedType_allocate);
  rb_define_method(SwigClassMDFeedType.klass, "initialize", VALUEFUNC(_wrap_new_MDFeedType), -1);
  SwigClassMDFeedType.mark = 0;
  SwigClassMDFeedType.destroy = (void (*)(void *)) free_FIX_MDFeedType;
  SwigClassMDFeedType.trackObjects = 0;
  
  SwigClassCollStatus.klass = rb_define_class_under(mQuickfix, "CollStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollStatus, (void *) &SwigClassCollStatus);
  rb_define_alloc_func(SwigClassCollStatus.klass, _wrap_CollStatus_allocate);
  rb_define_method(SwigClassCollStatus.klass, "initialize", VALUEFUNC(_wrap_new_CollStatus), -1);
  SwigClassCollStatus.mark = 0;
  SwigClassCollStatus.destroy = (void (*)(void *)) free_FIX_CollStatus;
  SwigClassCollStatus.trackObjects = 0;
  
  SwigClassUnderlyingSecuritySubType.klass = rb_define_class_under(mQuickfix, "UnderlyingSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecuritySubType, (void *) &SwigClassUnderlyingSecuritySubType);
  rb_define_alloc_func(SwigClassUnderlyingSecuritySubType.klass, _wrap_UnderlyingSecuritySubType_allocate);
  rb_define_method(SwigClassUnderlyingSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecuritySubType), -1);
  SwigClassUnderlyingSecuritySubType.mark = 0;
  SwigClassUnderlyingSecuritySubType.destroy = (void (*)(void *)) free_FIX_UnderlyingSecuritySubType;
  SwigClassUnderlyingSecuritySubType.trackObjects = 0;
  
  SwigClassCstmApplVerID.klass = rb_define_class_under(mQuickfix, "CstmApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CstmApplVerID, (void *) &SwigClassCstmApplVerID);
  rb_define_alloc_func(SwigClassCstmApplVerID.klass, _wrap_CstmApplVerID_allocate);
  rb_define_method(SwigClassCstmApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_CstmApplVerID), -1);
  SwigClassCstmApplVerID.mark = 0;
  SwigClassCstmApplVerID.destroy = (void (*)(void *)) free_FIX_CstmApplVerID;
  SwigClassCstmApplVerID.trackObjects = 0;
  
  SwigClassDefaultApplExtID.klass = rb_define_class_under(mQuickfix, "DefaultApplExtID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultApplExtID, (void *) &SwigClassDefaultApplExtID);
  rb_define_alloc_func(SwigClassDefaultApplExtID.klass, _wrap_DefaultApplExtID_allocate);
  rb_define_method(SwigClassDefaultApplExtID.klass, "initialize", VALUEFUNC(_wrap_new_DefaultApplExtID), -1);
  SwigClassDefaultApplExtID.mark = 0;
  SwigClassDefaultApplExtID.destroy = (void (*)(void *)) free_FIX_DefaultApplExtID;
  SwigClassDefaultApplExtID.trackObjects = 0;
  
  SwigClassNoDerivativeSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoDerivativeSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeSecurityAltID, (void *) &SwigClassNoDerivativeSecurityAltID);
  rb_define_alloc_func(SwigClassNoDerivativeSecurityAltID.klass, _wrap_NoDerivativeSecurityAltID_allocate);
  rb_define_method(SwigClassNoDerivativeSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeSecurityAltID), -1);
  SwigClassNoDerivativeSecurityAltID.mark = 0;
  SwigClassNoDerivativeSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoDerivativeSecurityAltID;
  SwigClassNoDerivativeSecurityAltID.trackObjects = 0;
  
  SwigClassSideValueInd.klass = rb_define_class_under(mQuickfix, "SideValueInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideValueInd, (void *) &SwigClassSideValueInd);
  rb_define_alloc_func(SwigClassSideValueInd.klass, _wrap_SideValueInd_allocate);
  rb_define_method(SwigClassSideValueInd.klass, "initialize", VALUEFUNC(_wrap_new_SideValueInd), -1);
  SwigClassSideValueInd.mark = 0;
  SwigClassSideValueInd.destroy = (void (*)(void *)) free_FIX_SideValueInd;
  SwigClassSideValueInd.trackObjects = 0;
  
  SwigClassEncodedText.klass = rb_define_class_under(mQuickfix, "EncodedText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedText, (void *) &SwigClassEncodedText);
  rb_define_alloc_func(SwigClassEncodedText.klass, _wrap_EncodedText_allocate);
  rb_define_method(SwigClassEncodedText.klass, "initialize", VALUEFUNC(_wrap_new_EncodedText), -1);
  SwigClassEncodedText.mark = 0;
  SwigClassEncodedText.destroy = (void (*)(void *)) free_FIX_EncodedText;
  SwigClassEncodedText.trackObjects = 0;
  
  SwigClassAccount.klass = rb_define_class_under(mQuickfix, "Account", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Account, (void *) &SwigClassAccount);
  rb_define_alloc_func(SwigClassAccount.klass, _wrap_Account_allocate);
  rb_define_method(SwigClassAccount.klass, "initialize", VALUEFUNC(_wrap_new_Account), -1);
  SwigClassAccount.mark = 0;
  SwigClassAccount.destroy = (void (*)(void *)) free_FIX_Account;
  SwigClassAccount.trackObjects = 0;
  
  SwigClassTriggerNewPrice.klass = rb_define_class_under(mQuickfix, "TriggerNewPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerNewPrice, (void *) &SwigClassTriggerNewPrice);
  rb_define_alloc_func(SwigClassTriggerNewPrice.klass, _wrap_TriggerNewPrice_allocate);
  rb_define_method(SwigClassTriggerNewPrice.klass, "initialize", VALUEFUNC(_wrap_new_TriggerNewPrice), -1);
  SwigClassTriggerNewPrice.mark = 0;
  SwigClassTriggerNewPrice.destroy = (void (*)(void *)) free_FIX_TriggerNewPrice;
  SwigClassTriggerNewPrice.trackObjects = 0;
  
  SwigClassUndlyInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyRole, (void *) &SwigClassUndlyInstrumentPartyRole);
  rb_define_alloc_func(SwigClassUndlyInstrumentPartyRole.klass, _wrap_UndlyInstrumentPartyRole_allocate);
  rb_define_method(SwigClassUndlyInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartyRole), -1);
  SwigClassUndlyInstrumentPartyRole.mark = 0;
  SwigClassUndlyInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartyRole;
  SwigClassUndlyInstrumentPartyRole.trackObjects = 0;
  
  SwigClassMsgDirection.klass = rb_define_class_under(mQuickfix, "MsgDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MsgDirection, (void *) &SwigClassMsgDirection);
  rb_define_alloc_func(SwigClassMsgDirection.klass, _wrap_MsgDirection_allocate);
  rb_define_method(SwigClassMsgDirection.klass, "initialize", VALUEFUNC(_wrap_new_MsgDirection), -1);
  SwigClassMsgDirection.mark = 0;
  SwigClassMsgDirection.destroy = (void (*)(void *)) free_FIX_MsgDirection;
  SwigClassMsgDirection.trackObjects = 0;
  
  SwigClassLegMaturityDate.klass = rb_define_class_under(mQuickfix, "LegMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegMaturityDate, (void *) &SwigClassLegMaturityDate);
  rb_define_alloc_func(SwigClassLegMaturityDate.klass, _wrap_LegMaturityDate_allocate);
  rb_define_method(SwigClassLegMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_LegMaturityDate), -1);
  SwigClassLegMaturityDate.mark = 0;
  SwigClassLegMaturityDate.destroy = (void (*)(void *)) free_FIX_LegMaturityDate;
  SwigClassLegMaturityDate.trackObjects = 0;
  
  SwigClassUnderlyingContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "UnderlyingContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit, (void *) &SwigClassUnderlyingContractMultiplierUnit);
  rb_define_alloc_func(SwigClassUnderlyingContractMultiplierUnit.klass, _wrap_UnderlyingContractMultiplierUnit_allocate);
  rb_define_method(SwigClassUnderlyingContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingContractMultiplierUnit), -1);
  SwigClassUnderlyingContractMultiplierUnit.mark = 0;
  SwigClassUnderlyingContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_UnderlyingContractMultiplierUnit;
  SwigClassUnderlyingContractMultiplierUnit.trackObjects = 0;
  
  SwigClassInputSource.klass = rb_define_class_under(mQuickfix, "InputSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InputSource, (void *) &SwigClassInputSource);
  rb_define_alloc_func(SwigClassInputSource.klass, _wrap_InputSource_allocate);
  rb_define_method(SwigClassInputSource.klass, "initialize", VALUEFUNC(_wrap_new_InputSource), -1);
  SwigClassInputSource.mark = 0;
  SwigClassInputSource.destroy = (void (*)(void *)) free_FIX_InputSource;
  SwigClassInputSource.trackObjects = 0;
  
  SwigClassMDUpdateAction.klass = rb_define_class_under(mQuickfix, "MDUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDUpdateAction, (void *) &SwigClassMDUpdateAction);
  rb_define_alloc_func(SwigClassMDUpdateAction.klass, _wrap_MDUpdateAction_allocate);
  rb_define_method(SwigClassMDUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_MDUpdateAction), -1);
  SwigClassMDUpdateAction.mark = 0;
  SwigClassMDUpdateAction.destroy = (void (*)(void *)) free_FIX_MDUpdateAction;
  SwigClassMDUpdateAction.trackObjects = 0;
  
  SwigClassMatchStatus.klass = rb_define_class_under(mQuickfix, "MatchStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchStatus, (void *) &SwigClassMatchStatus);
  rb_define_alloc_func(SwigClassMatchStatus.klass, _wrap_MatchStatus_allocate);
  rb_define_method(SwigClassMatchStatus.klass, "initialize", VALUEFUNC(_wrap_new_MatchStatus), -1);
  SwigClassMatchStatus.mark = 0;
  SwigClassMatchStatus.destroy = (void (*)(void *)) free_FIX_MatchStatus;
  SwigClassMatchStatus.trackObjects = 0;
  
  SwigClassRateSource.klass = rb_define_class_under(mQuickfix, "RateSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RateSource, (void *) &SwigClassRateSource);
  rb_define_alloc_func(SwigClassRateSource.klass, _wrap_RateSource_allocate);
  rb_define_method(SwigClassRateSource.klass, "initialize", VALUEFUNC(_wrap_new_RateSource), -1);
  SwigClassRateSource.mark = 0;
  SwigClassRateSource.destroy = (void (*)(void *)) free_FIX_RateSource;
  SwigClassRateSource.trackObjects = 0;
  
  SwigClassAllocPositionEffect.klass = rb_define_class_under(mQuickfix, "AllocPositionEffect", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocPositionEffect, (void *) &SwigClassAllocPositionEffect);
  rb_define_alloc_func(SwigClassAllocPositionEffect.klass, _wrap_AllocPositionEffect_allocate);
  rb_define_method(SwigClassAllocPositionEffect.klass, "initialize", VALUEFUNC(_wrap_new_AllocPositionEffect), -1);
  SwigClassAllocPositionEffect.mark = 0;
  SwigClassAllocPositionEffect.destroy = (void (*)(void *)) free_FIX_AllocPositionEffect;
  SwigClassAllocPositionEffect.trackObjects = 0;
  
  SwigClassPartyIDSource.klass = rb_define_class_under(mQuickfix, "PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyIDSource, (void *) &SwigClassPartyIDSource);
  rb_define_alloc_func(SwigClassPartyIDSource.klass, _wrap_PartyIDSource_allocate);
  rb_define_method(SwigClassPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_PartyIDSource), -1);
  SwigClassPartyIDSource.mark = 0;
  SwigClassPartyIDSource.destroy = (void (*)(void *)) free_FIX_PartyIDSource;
  SwigClassPartyIDSource.trackObjects = 0;
  
  SwigClassEncodedUnderlyingIssuer.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingIssuer, (void *) &SwigClassEncodedUnderlyingIssuer);
  rb_define_alloc_func(SwigClassEncodedUnderlyingIssuer.klass, _wrap_EncodedUnderlyingIssuer_allocate);
  rb_define_method(SwigClassEncodedUnderlyingIssuer.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingIssuer), -1);
  SwigClassEncodedUnderlyingIssuer.mark = 0;
  SwigClassEncodedUnderlyingIssuer.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingIssuer;
  SwigClassEncodedUnderlyingIssuer.trackObjects = 0;
  
  SwigClassEncryptedPassword.klass = rb_define_class_under(mQuickfix, "EncryptedPassword", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedPassword, (void *) &SwigClassEncryptedPassword);
  rb_define_alloc_func(SwigClassEncryptedPassword.klass, _wrap_EncryptedPassword_allocate);
  rb_define_method(SwigClassEncryptedPassword.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedPassword), -1);
  SwigClassEncryptedPassword.mark = 0;
  SwigClassEncryptedPassword.destroy = (void (*)(void *)) free_FIX_EncryptedPassword;
  SwigClassEncryptedPassword.trackObjects = 0;
  
  SwigClassTriggerNewQty.klass = rb_define_class_under(mQuickfix, "TriggerNewQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerNewQty, (void *) &SwigClassTriggerNewQty);
  rb_define_alloc_func(SwigClassTriggerNewQty.klass, _wrap_TriggerNewQty_allocate);
  rb_define_method(SwigClassTriggerNewQty.klass, "initialize", VALUEFUNC(_wrap_new_TriggerNewQty), -1);
  SwigClassTriggerNewQty.mark = 0;
  SwigClassTriggerNewQty.destroy = (void (*)(void *)) free_FIX_TriggerNewQty;
  SwigClassTriggerNewQty.trackObjects = 0;
  
  SwigClassLegLastForwardPoints.klass = rb_define_class_under(mQuickfix, "LegLastForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLastForwardPoints, (void *) &SwigClassLegLastForwardPoints);
  rb_define_alloc_func(SwigClassLegLastForwardPoints.klass, _wrap_LegLastForwardPoints_allocate);
  rb_define_method(SwigClassLegLastForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LegLastForwardPoints), -1);
  SwigClassLegLastForwardPoints.mark = 0;
  SwigClassLegLastForwardPoints.destroy = (void (*)(void *)) free_FIX_LegLastForwardPoints;
  SwigClassLegLastForwardPoints.trackObjects = 0;
  
  SwigClassTotNumTradeReports.klass = rb_define_class_under(mQuickfix, "TotNumTradeReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNumTradeReports, (void *) &SwigClassTotNumTradeReports);
  rb_define_alloc_func(SwigClassTotNumTradeReports.klass, _wrap_TotNumTradeReports_allocate);
  rb_define_method(SwigClassTotNumTradeReports.klass, "initialize", VALUEFUNC(_wrap_new_TotNumTradeReports), -1);
  SwigClassTotNumTradeReports.mark = 0;
  SwigClassTotNumTradeReports.destroy = (void (*)(void *)) free_FIX_TotNumTradeReports;
  SwigClassTotNumTradeReports.trackObjects = 0;
  
  SwigClassRefApplVerID.klass = rb_define_class_under(mQuickfix, "RefApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplVerID, (void *) &SwigClassRefApplVerID);
  rb_define_alloc_func(SwigClassRefApplVerID.klass, _wrap_RefApplVerID_allocate);
  rb_define_method(SwigClassRefApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplVerID), -1);
  SwigClassRefApplVerID.mark = 0;
  SwigClassRefApplVerID.destroy = (void (*)(void *)) free_FIX_RefApplVerID;
  SwigClassRefApplVerID.trackObjects = 0;
  
  SwigClassLastSpotRate.klass = rb_define_class_under(mQuickfix, "LastSpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastSpotRate, (void *) &SwigClassLastSpotRate);
  rb_define_alloc_func(SwigClassLastSpotRate.klass, _wrap_LastSpotRate_allocate);
  rb_define_method(SwigClassLastSpotRate.klass, "initialize", VALUEFUNC(_wrap_new_LastSpotRate), -1);
  SwigClassLastSpotRate.mark = 0;
  SwigClassLastSpotRate.destroy = (void (*)(void *)) free_FIX_LastSpotRate;
  SwigClassLastSpotRate.trackObjects = 0;
  
  SwigClassPrice.klass = rb_define_class_under(mQuickfix, "Price", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Price, (void *) &SwigClassPrice);
  rb_define_alloc_func(SwigClassPrice.klass, _wrap_Price_allocate);
  rb_define_method(SwigClassPrice.klass, "initialize", VALUEFUNC(_wrap_new_Price), -1);
  SwigClassPrice.mark = 0;
  SwigClassPrice.destroy = (void (*)(void *)) free_FIX_Price;
  SwigClassPrice.trackObjects = 0;
  
  SwigClassUnderlyingSecurityIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityIDSource, (void *) &SwigClassUnderlyingSecurityIDSource);
  rb_define_alloc_func(SwigClassUnderlyingSecurityIDSource.klass, _wrap_UnderlyingSecurityIDSource_allocate);
  rb_define_method(SwigClassUnderlyingSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityIDSource), -1);
  SwigClassUnderlyingSecurityIDSource.mark = 0;
  SwigClassUnderlyingSecurityIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityIDSource;
  SwigClassUnderlyingSecurityIDSource.trackObjects = 0;
  
  SwigClassTotNoSecurityTypes.klass = rb_define_class_under(mQuickfix, "TotNoSecurityTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoSecurityTypes, (void *) &SwigClassTotNoSecurityTypes);
  rb_define_alloc_func(SwigClassTotNoSecurityTypes.klass, _wrap_TotNoSecurityTypes_allocate);
  rb_define_method(SwigClassTotNoSecurityTypes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoSecurityTypes), -1);
  SwigClassTotNoSecurityTypes.mark = 0;
  SwigClassTotNoSecurityTypes.destroy = (void (*)(void *)) free_FIX_TotNoSecurityTypes;
  SwigClassTotNoSecurityTypes.trackObjects = 0;
  
  SwigClassReportedPx.klass = rb_define_class_under(mQuickfix, "ReportedPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReportedPx, (void *) &SwigClassReportedPx);
  rb_define_alloc_func(SwigClassReportedPx.klass, _wrap_ReportedPx_allocate);
  rb_define_method(SwigClassReportedPx.klass, "initialize", VALUEFUNC(_wrap_new_ReportedPx), -1);
  SwigClassReportedPx.mark = 0;
  SwigClassReportedPx.destroy = (void (*)(void *)) free_FIX_ReportedPx;
  SwigClassReportedPx.trackObjects = 0;
  
  SwigClassLegSymbol.klass = rb_define_class_under(mQuickfix, "LegSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSymbol, (void *) &SwigClassLegSymbol);
  rb_define_alloc_func(SwigClassLegSymbol.klass, _wrap_LegSymbol_allocate);
  rb_define_method(SwigClassLegSymbol.klass, "initialize", VALUEFUNC(_wrap_new_LegSymbol), -1);
  SwigClassLegSymbol.mark = 0;
  SwigClassLegSymbol.destroy = (void (*)(void *)) free_FIX_LegSymbol;
  SwigClassLegSymbol.trackObjects = 0;
  
  SwigClassLegIssuer.klass = rb_define_class_under(mQuickfix, "LegIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIssuer, (void *) &SwigClassLegIssuer);
  rb_define_alloc_func(SwigClassLegIssuer.klass, _wrap_LegIssuer_allocate);
  rb_define_method(SwigClassLegIssuer.klass, "initialize", VALUEFUNC(_wrap_new_LegIssuer), -1);
  SwigClassLegIssuer.mark = 0;
  SwigClassLegIssuer.destroy = (void (*)(void *)) free_FIX_LegIssuer;
  SwigClassLegIssuer.trackObjects = 0;
  
  SwigClassRegistDetls.klass = rb_define_class_under(mQuickfix, "RegistDetls", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistDetls, (void *) &SwigClassRegistDetls);
  rb_define_alloc_func(SwigClassRegistDetls.klass, _wrap_RegistDetls_allocate);
  rb_define_method(SwigClassRegistDetls.klass, "initialize", VALUEFUNC(_wrap_new_RegistDetls), -1);
  SwigClassRegistDetls.mark = 0;
  SwigClassRegistDetls.destroy = (void (*)(void *)) free_FIX_RegistDetls;
  SwigClassRegistDetls.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityID.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityID, (void *) &SwigClassUnderlyingLegSecurityID);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityID.klass, _wrap_UnderlyingLegSecurityID_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityID), -1);
  SwigClassUnderlyingLegSecurityID.mark = 0;
  SwigClassUnderlyingLegSecurityID.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityID;
  SwigClassUnderlyingLegSecurityID.trackObjects = 0;
  
  SwigClassMinLotSize.klass = rb_define_class_under(mQuickfix, "MinLotSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinLotSize, (void *) &SwigClassMinLotSize);
  rb_define_alloc_func(SwigClassMinLotSize.klass, _wrap_MinLotSize_allocate);
  rb_define_method(SwigClassMinLotSize.klass, "initialize", VALUEFUNC(_wrap_new_MinLotSize), -1);
  SwigClassMinLotSize.mark = 0;
  SwigClassMinLotSize.destroy = (void (*)(void *)) free_FIX_MinLotSize;
  SwigClassMinLotSize.trackObjects = 0;
  
  SwigClassNumTickets.klass = rb_define_class_under(mQuickfix, "NumTickets", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumTickets, (void *) &SwigClassNumTickets);
  rb_define_alloc_func(SwigClassNumTickets.klass, _wrap_NumTickets_allocate);
  rb_define_method(SwigClassNumTickets.klass, "initialize", VALUEFUNC(_wrap_new_NumTickets), -1);
  SwigClassNumTickets.mark = 0;
  SwigClassNumTickets.destroy = (void (*)(void *)) free_FIX_NumTickets;
  SwigClassNumTickets.trackObjects = 0;
  
  SwigClassLegLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "LegLocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLocaleOfIssue, (void *) &SwigClassLegLocaleOfIssue);
  rb_define_alloc_func(SwigClassLegLocaleOfIssue.klass, _wrap_LegLocaleOfIssue_allocate);
  rb_define_method(SwigClassLegLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LegLocaleOfIssue), -1);
  SwigClassLegLocaleOfIssue.mark = 0;
  SwigClassLegLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_LegLocaleOfIssue;
  SwigClassLegLocaleOfIssue.trackObjects = 0;
  
  SwigClassExchangeForPhysical.klass = rb_define_class_under(mQuickfix, "ExchangeForPhysical", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExchangeForPhysical, (void *) &SwigClassExchangeForPhysical);
  rb_define_alloc_func(SwigClassExchangeForPhysical.klass, _wrap_ExchangeForPhysical_allocate);
  rb_define_method(SwigClassExchangeForPhysical.klass, "initialize", VALUEFUNC(_wrap_new_ExchangeForPhysical), -1);
  SwigClassExchangeForPhysical.mark = 0;
  SwigClassExchangeForPhysical.destroy = (void (*)(void *)) free_FIX_ExchangeForPhysical;
  SwigClassExchangeForPhysical.trackObjects = 0;
  
  SwigClassSecurityTradingEvent.klass = rb_define_class_under(mQuickfix, "SecurityTradingEvent", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityTradingEvent, (void *) &SwigClassSecurityTradingEvent);
  rb_define_alloc_func(SwigClassSecurityTradingEvent.klass, _wrap_SecurityTradingEvent_allocate);
  rb_define_method(SwigClassSecurityTradingEvent.klass, "initialize", VALUEFUNC(_wrap_new_SecurityTradingEvent), -1);
  SwigClassSecurityTradingEvent.mark = 0;
  SwigClassSecurityTradingEvent.destroy = (void (*)(void *)) free_FIX_SecurityTradingEvent;
  SwigClassSecurityTradingEvent.trackObjects = 0;
  
  SwigClassMinPriceIncrementAmount.klass = rb_define_class_under(mQuickfix, "MinPriceIncrementAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinPriceIncrementAmount, (void *) &SwigClassMinPriceIncrementAmount);
  rb_define_alloc_func(SwigClassMinPriceIncrementAmount.klass, _wrap_MinPriceIncrementAmount_allocate);
  rb_define_method(SwigClassMinPriceIncrementAmount.klass, "initialize", VALUEFUNC(_wrap_new_MinPriceIncrementAmount), -1);
  SwigClassMinPriceIncrementAmount.mark = 0;
  SwigClassMinPriceIncrementAmount.destroy = (void (*)(void *)) free_FIX_MinPriceIncrementAmount;
  SwigClassMinPriceIncrementAmount.trackObjects = 0;
  
  SwigClassUnderlyingPayAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingPayAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPayAmount, (void *) &SwigClassUnderlyingPayAmount);
  rb_define_alloc_func(SwigClassUnderlyingPayAmount.klass, _wrap_UnderlyingPayAmount_allocate);
  rb_define_method(SwigClassUnderlyingPayAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPayAmount), -1);
  SwigClassUnderlyingPayAmount.mark = 0;
  SwigClassUnderlyingPayAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingPayAmount;
  SwigClassUnderlyingPayAmount.trackObjects = 0;
  
  SwigClassSettlPartySubID.klass = rb_define_class_under(mQuickfix, "SettlPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartySubID, (void *) &SwigClassSettlPartySubID);
  rb_define_alloc_func(SwigClassSettlPartySubID.klass, _wrap_SettlPartySubID_allocate);
  rb_define_method(SwigClassSettlPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartySubID), -1);
  SwigClassSettlPartySubID.mark = 0;
  SwigClassSettlPartySubID.destroy = (void (*)(void *)) free_FIX_SettlPartySubID;
  SwigClassSettlPartySubID.trackObjects = 0;
  
  SwigClassAllocNetMoney.klass = rb_define_class_under(mQuickfix, "AllocNetMoney", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocNetMoney, (void *) &SwigClassAllocNetMoney);
  rb_define_alloc_func(SwigClassAllocNetMoney.klass, _wrap_AllocNetMoney_allocate);
  rb_define_method(SwigClassAllocNetMoney.klass, "initialize", VALUEFUNC(_wrap_new_AllocNetMoney), -1);
  SwigClassAllocNetMoney.mark = 0;
  SwigClassAllocNetMoney.destroy = (void (*)(void *)) free_FIX_AllocNetMoney;
  SwigClassAllocNetMoney.trackObjects = 0;
  
  SwigClassUnderlyingMaturityDay.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityDay", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityDay, (void *) &SwigClassUnderlyingMaturityDay);
  rb_define_alloc_func(SwigClassUnderlyingMaturityDay.klass, _wrap_UnderlyingMaturityDay_allocate);
  rb_define_method(SwigClassUnderlyingMaturityDay.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityDay), -1);
  SwigClassUnderlyingMaturityDay.mark = 0;
  SwigClassUnderlyingMaturityDay.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityDay;
  SwigClassUnderlyingMaturityDay.trackObjects = 0;
  
  SwigClassNetworkResponseID.klass = rb_define_class_under(mQuickfix, "NetworkResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkResponseID, (void *) &SwigClassNetworkResponseID);
  rb_define_alloc_func(SwigClassNetworkResponseID.klass, _wrap_NetworkResponseID_allocate);
  rb_define_method(SwigClassNetworkResponseID.klass, "initialize", VALUEFUNC(_wrap_new_NetworkResponseID), -1);
  SwigClassNetworkResponseID.mark = 0;
  SwigClassNetworkResponseID.destroy = (void (*)(void *)) free_FIX_NetworkResponseID;
  SwigClassNetworkResponseID.trackObjects = 0;
  
  SwigClassNumBidders.klass = rb_define_class_under(mQuickfix, "NumBidders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumBidders, (void *) &SwigClassNumBidders);
  rb_define_alloc_func(SwigClassNumBidders.klass, _wrap_NumBidders_allocate);
  rb_define_method(SwigClassNumBidders.klass, "initialize", VALUEFUNC(_wrap_new_NumBidders), -1);
  SwigClassNumBidders.mark = 0;
  SwigClassNumBidders.destroy = (void (*)(void *)) free_FIX_NumBidders;
  SwigClassNumBidders.trackObjects = 0;
  
  SwigClassAllocAcctIDSource.klass = rb_define_class_under(mQuickfix, "AllocAcctIDSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAcctIDSource, (void *) &SwigClassAllocAcctIDSource);
  rb_define_alloc_func(SwigClassAllocAcctIDSource.klass, _wrap_AllocAcctIDSource_allocate);
  rb_define_method(SwigClassAllocAcctIDSource.klass, "initialize", VALUEFUNC(_wrap_new_AllocAcctIDSource), -1);
  SwigClassAllocAcctIDSource.mark = 0;
  SwigClassAllocAcctIDSource.destroy = (void (*)(void *)) free_FIX_AllocAcctIDSource;
  SwigClassAllocAcctIDSource.trackObjects = 0;
  
  SwigClassAllocAvgPx.klass = rb_define_class_under(mQuickfix, "AllocAvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAvgPx, (void *) &SwigClassAllocAvgPx);
  rb_define_alloc_func(SwigClassAllocAvgPx.klass, _wrap_AllocAvgPx_allocate);
  rb_define_method(SwigClassAllocAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_AllocAvgPx), -1);
  SwigClassAllocAvgPx.mark = 0;
  SwigClassAllocAvgPx.destroy = (void (*)(void *)) free_FIX_AllocAvgPx;
  SwigClassAllocAvgPx.trackObjects = 0;
  
  SwigClassSecuritySettlAgentCode.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentCode, (void *) &SwigClassSecuritySettlAgentCode);
  rb_define_alloc_func(SwigClassSecuritySettlAgentCode.klass, _wrap_SecuritySettlAgentCode_allocate);
  rb_define_method(SwigClassSecuritySettlAgentCode.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentCode), -1);
  SwigClassSecuritySettlAgentCode.mark = 0;
  SwigClassSecuritySettlAgentCode.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentCode;
  SwigClassSecuritySettlAgentCode.trackObjects = 0;
  
  SwigClassNoDistribInsts.klass = rb_define_class_under(mQuickfix, "NoDistribInsts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDistribInsts, (void *) &SwigClassNoDistribInsts);
  rb_define_alloc_func(SwigClassNoDistribInsts.klass, _wrap_NoDistribInsts_allocate);
  rb_define_method(SwigClassNoDistribInsts.klass, "initialize", VALUEFUNC(_wrap_new_NoDistribInsts), -1);
  SwigClassNoDistribInsts.mark = 0;
  SwigClassNoDistribInsts.destroy = (void (*)(void *)) free_FIX_NoDistribInsts;
  SwigClassNoDistribInsts.trackObjects = 0;
  
  SwigClassCustDirectedOrder.klass = rb_define_class_under(mQuickfix, "CustDirectedOrder", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustDirectedOrder, (void *) &SwigClassCustDirectedOrder);
  rb_define_alloc_func(SwigClassCustDirectedOrder.klass, _wrap_CustDirectedOrder_allocate);
  rb_define_method(SwigClassCustDirectedOrder.klass, "initialize", VALUEFUNC(_wrap_new_CustDirectedOrder), -1);
  SwigClassCustDirectedOrder.mark = 0;
  SwigClassCustDirectedOrder.destroy = (void (*)(void *)) free_FIX_CustDirectedOrder;
  SwigClassCustDirectedOrder.trackObjects = 0;
  
  SwigClassFairValue.klass = rb_define_class_under(mQuickfix, "FairValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FairValue, (void *) &SwigClassFairValue);
  rb_define_alloc_func(SwigClassFairValue.klass, _wrap_FairValue_allocate);
  rb_define_method(SwigClassFairValue.klass, "initialize", VALUEFUNC(_wrap_new_FairValue), -1);
  SwigClassFairValue.mark = 0;
  SwigClassFairValue.destroy = (void (*)(void *)) free_FIX_FairValue;
  SwigClassFairValue.trackObjects = 0;
  
  SwigClassNoStrikes.klass = rb_define_class_under(mQuickfix, "NoStrikes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStrikes, (void *) &SwigClassNoStrikes);
  rb_define_alloc_func(SwigClassNoStrikes.klass, _wrap_NoStrikes_allocate);
  rb_define_method(SwigClassNoStrikes.klass, "initialize", VALUEFUNC(_wrap_new_NoStrikes), -1);
  SwigClassNoStrikes.mark = 0;
  SwigClassNoStrikes.destroy = (void (*)(void *)) free_FIX_NoStrikes;
  SwigClassNoStrikes.trackObjects = 0;
  
  SwigClassEncodedSecurityListDescLen.klass = rb_define_class_under(mQuickfix, "EncodedSecurityListDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityListDescLen, (void *) &SwigClassEncodedSecurityListDescLen);
  rb_define_alloc_func(SwigClassEncodedSecurityListDescLen.klass, _wrap_EncodedSecurityListDescLen_allocate);
  rb_define_method(SwigClassEncodedSecurityListDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityListDescLen), -1);
  SwigClassEncodedSecurityListDescLen.mark = 0;
  SwigClassEncodedSecurityListDescLen.destroy = (void (*)(void *)) free_FIX_EncodedSecurityListDescLen;
  SwigClassEncodedSecurityListDescLen.trackObjects = 0;
  
  SwigClassLegExerciseStyle.klass = rb_define_class_under(mQuickfix, "LegExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegExerciseStyle, (void *) &SwigClassLegExerciseStyle);
  rb_define_alloc_func(SwigClassLegExerciseStyle.klass, _wrap_LegExerciseStyle_allocate);
  rb_define_method(SwigClassLegExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_LegExerciseStyle), -1);
  SwigClassLegExerciseStyle.mark = 0;
  SwigClassLegExerciseStyle.destroy = (void (*)(void *)) free_FIX_LegExerciseStyle;
  SwigClassLegExerciseStyle.trackObjects = 0;
  
  SwigClassDerivativeSymbolSfx.klass = rb_define_class_under(mQuickfix, "DerivativeSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSymbolSfx, (void *) &SwigClassDerivativeSymbolSfx);
  rb_define_alloc_func(SwigClassDerivativeSymbolSfx.klass, _wrap_DerivativeSymbolSfx_allocate);
  rb_define_method(SwigClassDerivativeSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSymbolSfx), -1);
  SwigClassDerivativeSymbolSfx.mark = 0;
  SwigClassDerivativeSymbolSfx.destroy = (void (*)(void *)) free_FIX_DerivativeSymbolSfx;
  SwigClassDerivativeSymbolSfx.trackObjects = 0;
  
  SwigClassNestedInstrAttribType.klass = rb_define_class_under(mQuickfix, "NestedInstrAttribType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedInstrAttribType, (void *) &SwigClassNestedInstrAttribType);
  rb_define_alloc_func(SwigClassNestedInstrAttribType.klass, _wrap_NestedInstrAttribType_allocate);
  rb_define_method(SwigClassNestedInstrAttribType.klass, "initialize", VALUEFUNC(_wrap_new_NestedInstrAttribType), -1);
  SwigClassNestedInstrAttribType.mark = 0;
  SwigClassNestedInstrAttribType.destroy = (void (*)(void *)) free_FIX_NestedInstrAttribType;
  SwigClassNestedInstrAttribType.trackObjects = 0;
  
  SwigClassContraTrader.klass = rb_define_class_under(mQuickfix, "ContraTrader", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraTrader, (void *) &SwigClassContraTrader);
  rb_define_alloc_func(SwigClassContraTrader.klass, _wrap_ContraTrader_allocate);
  rb_define_method(SwigClassContraTrader.klass, "initialize", VALUEFUNC(_wrap_new_ContraTrader), -1);
  SwigClassContraTrader.mark = 0;
  SwigClassContraTrader.destroy = (void (*)(void *)) free_FIX_ContraTrader;
  SwigClassContraTrader.trackObjects = 0;
  
  SwigClassMDSecSize.klass = rb_define_class_under(mQuickfix, "MDSecSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDSecSize, (void *) &SwigClassMDSecSize);
  rb_define_alloc_func(SwigClassMDSecSize.klass, _wrap_MDSecSize_allocate);
  rb_define_method(SwigClassMDSecSize.klass, "initialize", VALUEFUNC(_wrap_new_MDSecSize), -1);
  SwigClassMDSecSize.mark = 0;
  SwigClassMDSecSize.destroy = (void (*)(void *)) free_FIX_MDSecSize;
  SwigClassMDSecSize.trackObjects = 0;
  
  SwigClassNoOfSecSizes.klass = rb_define_class_under(mQuickfix, "NoOfSecSizes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOfSecSizes, (void *) &SwigClassNoOfSecSizes);
  rb_define_alloc_func(SwigClassNoOfSecSizes.klass, _wrap_NoOfSecSizes_allocate);
  rb_define_method(SwigClassNoOfSecSizes.klass, "initialize", VALUEFUNC(_wrap_new_NoOfSecSizes), -1);
  SwigClassNoOfSecSizes.mark = 0;
  SwigClassNoOfSecSizes.destroy = (void (*)(void *)) free_FIX_NoOfSecSizes;
  SwigClassNoOfSecSizes.trackObjects = 0;
  
  SwigClassCollAction.klass = rb_define_class_under(mQuickfix, "CollAction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAction, (void *) &SwigClassCollAction);
  rb_define_alloc_func(SwigClassCollAction.klass, _wrap_CollAction_allocate);
  rb_define_method(SwigClassCollAction.klass, "initialize", VALUEFUNC(_wrap_new_CollAction), -1);
  SwigClassCollAction.mark = 0;
  SwigClassCollAction.destroy = (void (*)(void *)) free_FIX_CollAction;
  SwigClassCollAction.trackObjects = 0;
  
  SwigClassUnderlyingLastQty.klass = rb_define_class_under(mQuickfix, "UnderlyingLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLastQty, (void *) &SwigClassUnderlyingLastQty);
  rb_define_alloc_func(SwigClassUnderlyingLastQty.klass, _wrap_UnderlyingLastQty_allocate);
  rb_define_method(SwigClassUnderlyingLastQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLastQty), -1);
  SwigClassUnderlyingLastQty.mark = 0;
  SwigClassUnderlyingLastQty.destroy = (void (*)(void *)) free_FIX_UnderlyingLastQty;
  SwigClassUnderlyingLastQty.trackObjects = 0;
  
  SwigClassPossDupFlag.klass = rb_define_class_under(mQuickfix, "PossDupFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PossDupFlag, (void *) &SwigClassPossDupFlag);
  rb_define_alloc_func(SwigClassPossDupFlag.klass, _wrap_PossDupFlag_allocate);
  rb_define_method(SwigClassPossDupFlag.klass, "initialize", VALUEFUNC(_wrap_new_PossDupFlag), -1);
  SwigClassPossDupFlag.mark = 0;
  SwigClassPossDupFlag.destroy = (void (*)(void *)) free_FIX_PossDupFlag;
  SwigClassPossDupFlag.trackObjects = 0;
  
  SwigClassListStatusType.klass = rb_define_class_under(mQuickfix, "ListStatusType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListStatusType, (void *) &SwigClassListStatusType);
  rb_define_alloc_func(SwigClassListStatusType.klass, _wrap_ListStatusType_allocate);
  rb_define_method(SwigClassListStatusType.klass, "initialize", VALUEFUNC(_wrap_new_ListStatusType), -1);
  SwigClassListStatusType.mark = 0;
  SwigClassListStatusType.destroy = (void (*)(void *)) free_FIX_ListStatusType;
  SwigClassListStatusType.trackObjects = 0;
  
  SwigClassSideFillStationCd.klass = rb_define_class_under(mQuickfix, "SideFillStationCd", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideFillStationCd, (void *) &SwigClassSideFillStationCd);
  rb_define_alloc_func(SwigClassSideFillStationCd.klass, _wrap_SideFillStationCd_allocate);
  rb_define_method(SwigClassSideFillStationCd.klass, "initialize", VALUEFUNC(_wrap_new_SideFillStationCd), -1);
  SwigClassSideFillStationCd.mark = 0;
  SwigClassSideFillStationCd.destroy = (void (*)(void *)) free_FIX_SideFillStationCd;
  SwigClassSideFillStationCd.trackObjects = 0;
  
  SwigClassStatusText.klass = rb_define_class_under(mQuickfix, "StatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StatusText, (void *) &SwigClassStatusText);
  rb_define_alloc_func(SwigClassStatusText.klass, _wrap_StatusText_allocate);
  rb_define_method(SwigClassStatusText.klass, "initialize", VALUEFUNC(_wrap_new_StatusText), -1);
  SwigClassStatusText.mark = 0;
  SwigClassStatusText.destroy = (void (*)(void *)) free_FIX_StatusText;
  SwigClassStatusText.trackObjects = 0;
  
  SwigClassBasisFeatureDate.klass = rb_define_class_under(mQuickfix, "BasisFeatureDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BasisFeatureDate, (void *) &SwigClassBasisFeatureDate);
  rb_define_alloc_func(SwigClassBasisFeatureDate.klass, _wrap_BasisFeatureDate_allocate);
  rb_define_method(SwigClassBasisFeatureDate.klass, "initialize", VALUEFUNC(_wrap_new_BasisFeatureDate), -1);
  SwigClassBasisFeatureDate.mark = 0;
  SwigClassBasisFeatureDate.destroy = (void (*)(void *)) free_FIX_BasisFeatureDate;
  SwigClassBasisFeatureDate.trackObjects = 0;
  
  SwigClassXmlDataLen.klass = rb_define_class_under(mQuickfix, "XmlDataLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__XmlDataLen, (void *) &SwigClassXmlDataLen);
  rb_define_alloc_func(SwigClassXmlDataLen.klass, _wrap_XmlDataLen_allocate);
  rb_define_method(SwigClassXmlDataLen.klass, "initialize", VALUEFUNC(_wrap_new_XmlDataLen), -1);
  SwigClassXmlDataLen.mark = 0;
  SwigClassXmlDataLen.destroy = (void (*)(void *)) free_FIX_XmlDataLen;
  SwigClassXmlDataLen.trackObjects = 0;
  
  SwigClassUnderlyingMaturityDate.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityDate, (void *) &SwigClassUnderlyingMaturityDate);
  rb_define_alloc_func(SwigClassUnderlyingMaturityDate.klass, _wrap_UnderlyingMaturityDate_allocate);
  rb_define_method(SwigClassUnderlyingMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityDate), -1);
  SwigClassUnderlyingMaturityDate.mark = 0;
  SwigClassUnderlyingMaturityDate.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityDate;
  SwigClassUnderlyingMaturityDate.trackObjects = 0;
  
  SwigClassGapFillFlag.klass = rb_define_class_under(mQuickfix, "GapFillFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__GapFillFlag, (void *) &SwigClassGapFillFlag);
  rb_define_alloc_func(SwigClassGapFillFlag.klass, _wrap_GapFillFlag_allocate);
  rb_define_method(SwigClassGapFillFlag.klass, "initialize", VALUEFUNC(_wrap_new_GapFillFlag), -1);
  SwigClassGapFillFlag.mark = 0;
  SwigClassGapFillFlag.destroy = (void (*)(void *)) free_FIX_GapFillFlag;
  SwigClassGapFillFlag.trackObjects = 0;
  
  SwigClassRefApplExtID.klass = rb_define_class_under(mQuickfix, "RefApplExtID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplExtID, (void *) &SwigClassRefApplExtID);
  rb_define_alloc_func(SwigClassRefApplExtID.klass, _wrap_RefApplExtID_allocate);
  rb_define_method(SwigClassRefApplExtID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplExtID), -1);
  SwigClassRefApplExtID.mark = 0;
  SwigClassRefApplExtID.destroy = (void (*)(void *)) free_FIX_RefApplExtID;
  SwigClassRefApplExtID.trackObjects = 0;
  
  SwigClassRefApplID.klass = rb_define_class_under(mQuickfix, "RefApplID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplID, (void *) &SwigClassRefApplID);
  rb_define_alloc_func(SwigClassRefApplID.klass, _wrap_RefApplID_allocate);
  rb_define_method(SwigClassRefApplID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplID), -1);
  SwigClassRefApplID.mark = 0;
  SwigClassRefApplID.destroy = (void (*)(void *)) free_FIX_RefApplID;
  SwigClassRefApplID.trackObjects = 0;
  
  SwigClassNoTradingSessionRules.klass = rb_define_class_under(mQuickfix, "NoTradingSessionRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTradingSessionRules, (void *) &SwigClassNoTradingSessionRules);
  rb_define_alloc_func(SwigClassNoTradingSessionRules.klass, _wrap_NoTradingSessionRules_allocate);
  rb_define_method(SwigClassNoTradingSessionRules.klass, "initialize", VALUEFUNC(_wrap_new_NoTradingSessionRules), -1);
  SwigClassNoTradingSessionRules.mark = 0;
  SwigClassNoTradingSessionRules.destroy = (void (*)(void *)) free_FIX_NoTradingSessionRules;
  SwigClassNoTradingSessionRules.trackObjects = 0;
  
  SwigClassSwapPoints.klass = rb_define_class_under(mQuickfix, "SwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SwapPoints, (void *) &SwigClassSwapPoints);
  rb_define_alloc_func(SwigClassSwapPoints.klass, _wrap_SwapPoints_allocate);
  rb_define_method(SwigClassSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_SwapPoints), -1);
  SwigClassSwapPoints.mark = 0;
  SwigClassSwapPoints.destroy = (void (*)(void *)) free_FIX_SwapPoints;
  SwigClassSwapPoints.trackObjects = 0;
  
  SwigClassTargetStrategyParameters.klass = rb_define_class_under(mQuickfix, "TargetStrategyParameters", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetStrategyParameters, (void *) &SwigClassTargetStrategyParameters);
  rb_define_alloc_func(SwigClassTargetStrategyParameters.klass, _wrap_TargetStrategyParameters_allocate);
  rb_define_method(SwigClassTargetStrategyParameters.klass, "initialize", VALUEFUNC(_wrap_new_TargetStrategyParameters), -1);
  SwigClassTargetStrategyParameters.mark = 0;
  SwigClassTargetStrategyParameters.destroy = (void (*)(void *)) free_FIX_TargetStrategyParameters;
  SwigClassTargetStrategyParameters.trackObjects = 0;
  
  SwigClassLastForwardPoints.klass = rb_define_class_under(mQuickfix, "LastForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastForwardPoints, (void *) &SwigClassLastForwardPoints);
  rb_define_alloc_func(SwigClassLastForwardPoints.klass, _wrap_LastForwardPoints_allocate);
  rb_define_method(SwigClassLastForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LastForwardPoints), -1);
  SwigClassLastForwardPoints.mark = 0;
  SwigClassLastForwardPoints.destroy = (void (*)(void *)) free_FIX_LastForwardPoints;
  SwigClassLastForwardPoints.trackObjects = 0;
  
  SwigClassYieldRedemptionDate.klass = rb_define_class_under(mQuickfix, "YieldRedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldRedemptionDate, (void *) &SwigClassYieldRedemptionDate);
  rb_define_alloc_func(SwigClassYieldRedemptionDate.klass, _wrap_YieldRedemptionDate_allocate);
  rb_define_method(SwigClassYieldRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_YieldRedemptionDate), -1);
  SwigClassYieldRedemptionDate.mark = 0;
  SwigClassYieldRedemptionDate.destroy = (void (*)(void *)) free_FIX_YieldRedemptionDate;
  SwigClassYieldRedemptionDate.trackObjects = 0;
  
  SwigClassNoSettlDetails.klass = rb_define_class_under(mQuickfix, "NoSettlDetails", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlDetails, (void *) &SwigClassNoSettlDetails);
  rb_define_alloc_func(SwigClassNoSettlDetails.klass, _wrap_NoSettlDetails_allocate);
  rb_define_method(SwigClassNoSettlDetails.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlDetails), -1);
  SwigClassNoSettlDetails.mark = 0;
  SwigClassNoSettlDetails.destroy = (void (*)(void *)) free_FIX_NoSettlDetails;
  SwigClassNoSettlDetails.trackObjects = 0;
  
  SwigClassTradeHandlingInstr.klass = rb_define_class_under(mQuickfix, "TradeHandlingInstr", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeHandlingInstr, (void *) &SwigClassTradeHandlingInstr);
  rb_define_alloc_func(SwigClassTradeHandlingInstr.klass, _wrap_TradeHandlingInstr_allocate);
  rb_define_method(SwigClassTradeHandlingInstr.klass, "initialize", VALUEFUNC(_wrap_new_TradeHandlingInstr), -1);
  SwigClassTradeHandlingInstr.mark = 0;
  SwigClassTradeHandlingInstr.destroy = (void (*)(void *)) free_FIX_TradeHandlingInstr;
  SwigClassTradeHandlingInstr.trackObjects = 0;
  
  SwigClassCashSettlAgentCode.klass = rb_define_class_under(mQuickfix, "CashSettlAgentCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentCode, (void *) &SwigClassCashSettlAgentCode);
  rb_define_alloc_func(SwigClassCashSettlAgentCode.klass, _wrap_CashSettlAgentCode_allocate);
  rb_define_method(SwigClassCashSettlAgentCode.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentCode), -1);
  SwigClassCashSettlAgentCode.mark = 0;
  SwigClassCashSettlAgentCode.destroy = (void (*)(void *)) free_FIX_CashSettlAgentCode;
  SwigClassCashSettlAgentCode.trackObjects = 0;
  
  SwigClassLegPriceType.klass = rb_define_class_under(mQuickfix, "LegPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPriceType, (void *) &SwigClassLegPriceType);
  rb_define_alloc_func(SwigClassLegPriceType.klass, _wrap_LegPriceType_allocate);
  rb_define_method(SwigClassLegPriceType.klass, "initialize", VALUEFUNC(_wrap_new_LegPriceType), -1);
  SwigClassLegPriceType.mark = 0;
  SwigClassLegPriceType.destroy = (void (*)(void *)) free_FIX_LegPriceType;
  SwigClassLegPriceType.trackObjects = 0;
  
  SwigClassEncodedListExecInstLen.klass = rb_define_class_under(mQuickfix, "EncodedListExecInstLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListExecInstLen, (void *) &SwigClassEncodedListExecInstLen);
  rb_define_alloc_func(SwigClassEncodedListExecInstLen.klass, _wrap_EncodedListExecInstLen_allocate);
  rb_define_method(SwigClassEncodedListExecInstLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListExecInstLen), -1);
  SwigClassEncodedListExecInstLen.mark = 0;
  SwigClassEncodedListExecInstLen.destroy = (void (*)(void *)) free_FIX_EncodedListExecInstLen;
  SwigClassEncodedListExecInstLen.trackObjects = 0;
  
  SwigClassTradSesMethod.klass = rb_define_class_under(mQuickfix, "TradSesMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesMethod, (void *) &SwigClassTradSesMethod);
  rb_define_alloc_func(SwigClassTradSesMethod.klass, _wrap_TradSesMethod_allocate);
  rb_define_method(SwigClassTradSesMethod.klass, "initialize", VALUEFUNC(_wrap_new_TradSesMethod), -1);
  SwigClassTradSesMethod.mark = 0;
  SwigClassTradSesMethod.destroy = (void (*)(void *)) free_FIX_TradSesMethod;
  SwigClassTradSesMethod.trackObjects = 0;
  
  SwigClassAgreementID.klass = rb_define_class_under(mQuickfix, "AgreementID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementID, (void *) &SwigClassAgreementID);
  rb_define_alloc_func(SwigClassAgreementID.klass, _wrap_AgreementID_allocate);
  rb_define_method(SwigClassAgreementID.klass, "initialize", VALUEFUNC(_wrap_new_AgreementID), -1);
  SwigClassAgreementID.mark = 0;
  SwigClassAgreementID.destroy = (void (*)(void *)) free_FIX_AgreementID;
  SwigClassAgreementID.trackObjects = 0;
  
  SwigClassCashDistribCurr.klass = rb_define_class_under(mQuickfix, "CashDistribCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribCurr, (void *) &SwigClassCashDistribCurr);
  rb_define_alloc_func(SwigClassCashDistribCurr.klass, _wrap_CashDistribCurr_allocate);
  rb_define_method(SwigClassCashDistribCurr.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribCurr), -1);
  SwigClassCashDistribCurr.mark = 0;
  SwigClassCashDistribCurr.destroy = (void (*)(void *)) free_FIX_CashDistribCurr;
  SwigClassCashDistribCurr.trackObjects = 0;
  
  SwigClassBidPx.klass = rb_define_class_under(mQuickfix, "BidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidPx, (void *) &SwigClassBidPx);
  rb_define_alloc_func(SwigClassBidPx.klass, _wrap_BidPx_allocate);
  rb_define_method(SwigClassBidPx.klass, "initialize", VALUEFUNC(_wrap_new_BidPx), -1);
  SwigClassBidPx.mark = 0;
  SwigClassBidPx.destroy = (void (*)(void *)) free_FIX_BidPx;
  SwigClassBidPx.trackObjects = 0;
  
  SwigClassTradeType.klass = rb_define_class_under(mQuickfix, "TradeType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeType, (void *) &SwigClassTradeType);
  rb_define_alloc_func(SwigClassTradeType.klass, _wrap_TradeType_allocate);
  rb_define_method(SwigClassTradeType.klass, "initialize", VALUEFUNC(_wrap_new_TradeType), -1);
  SwigClassTradeType.mark = 0;
  SwigClassTradeType.destroy = (void (*)(void *)) free_FIX_TradeType;
  SwigClassTradeType.trackObjects = 0;
  
  SwigClassEncodedSecurityDescLen.klass = rb_define_class_under(mQuickfix, "EncodedSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityDescLen, (void *) &SwigClassEncodedSecurityDescLen);
  rb_define_alloc_func(SwigClassEncodedSecurityDescLen.klass, _wrap_EncodedSecurityDescLen_allocate);
  rb_define_method(SwigClassEncodedSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityDescLen), -1);
  SwigClassEncodedSecurityDescLen.mark = 0;
  SwigClassEncodedSecurityDescLen.destroy = (void (*)(void *)) free_FIX_EncodedSecurityDescLen;
  SwigClassEncodedSecurityDescLen.trackObjects = 0;
  
  SwigClassComplexEventCondition.klass = rb_define_class_under(mQuickfix, "ComplexEventCondition", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventCondition, (void *) &SwigClassComplexEventCondition);
  rb_define_alloc_func(SwigClassComplexEventCondition.klass, _wrap_ComplexEventCondition_allocate);
  rb_define_method(SwigClassComplexEventCondition.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventCondition), -1);
  SwigClassComplexEventCondition.mark = 0;
  SwigClassComplexEventCondition.destroy = (void (*)(void *)) free_FIX_ComplexEventCondition;
  SwigClassComplexEventCondition.trackObjects = 0;
  
  SwigClassEncryptedPasswordMethod.klass = rb_define_class_under(mQuickfix, "EncryptedPasswordMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedPasswordMethod, (void *) &SwigClassEncryptedPasswordMethod);
  rb_define_alloc_func(SwigClassEncryptedPasswordMethod.klass, _wrap_EncryptedPasswordMethod_allocate);
  rb_define_method(SwigClassEncryptedPasswordMethod.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedPasswordMethod), -1);
  SwigClassEncryptedPasswordMethod.mark = 0;
  SwigClassEncryptedPasswordMethod.destroy = (void (*)(void *)) free_FIX_EncryptedPasswordMethod;
  SwigClassEncryptedPasswordMethod.trackObjects = 0;
  
  SwigClassDerivativeSecurityAltID.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityAltID, (void *) &SwigClassDerivativeSecurityAltID);
  rb_define_alloc_func(SwigClassDerivativeSecurityAltID.klass, _wrap_DerivativeSecurityAltID_allocate);
  rb_define_method(SwigClassDerivativeSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityAltID), -1);
  SwigClassDerivativeSecurityAltID.mark = 0;
  SwigClassDerivativeSecurityAltID.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityAltID;
  SwigClassDerivativeSecurityAltID.trackObjects = 0;
  
  SwigClassTotNoAccQuotes.klass = rb_define_class_under(mQuickfix, "TotNoAccQuotes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoAccQuotes, (void *) &SwigClassTotNoAccQuotes);
  rb_define_alloc_func(SwigClassTotNoAccQuotes.klass, _wrap_TotNoAccQuotes_allocate);
  rb_define_method(SwigClassTotNoAccQuotes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoAccQuotes), -1);
  SwigClassTotNoAccQuotes.mark = 0;
  SwigClassTotNoAccQuotes.destroy = (void (*)(void *)) free_FIX_TotNoAccQuotes;
  SwigClassTotNoAccQuotes.trackObjects = 0;
  
  SwigClassTimeBracket.klass = rb_define_class_under(mQuickfix, "TimeBracket", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeBracket, (void *) &SwigClassTimeBracket);
  rb_define_alloc_func(SwigClassTimeBracket.klass, _wrap_TimeBracket_allocate);
  rb_define_method(SwigClassTimeBracket.klass, "initialize", VALUEFUNC(_wrap_new_TimeBracket), -1);
  SwigClassTimeBracket.mark = 0;
  SwigClassTimeBracket.destroy = (void (*)(void *)) free_FIX_TimeBracket;
  SwigClassTimeBracket.trackObjects = 0;
  
  SwigClassNoAllocs.klass = rb_define_class_under(mQuickfix, "NoAllocs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAllocs, (void *) &SwigClassNoAllocs);
  rb_define_alloc_func(SwigClassNoAllocs.klass, _wrap_NoAllocs_allocate);
  rb_define_method(SwigClassNoAllocs.klass, "initialize", VALUEFUNC(_wrap_new_NoAllocs), -1);
  SwigClassNoAllocs.mark = 0;
  SwigClassNoAllocs.destroy = (void (*)(void *)) free_FIX_NoAllocs;
  SwigClassNoAllocs.trackObjects = 0;
  
  SwigClassUnderlyingProduct.klass = rb_define_class_under(mQuickfix, "UnderlyingProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingProduct, (void *) &SwigClassUnderlyingProduct);
  rb_define_alloc_func(SwigClassUnderlyingProduct.klass, _wrap_UnderlyingProduct_allocate);
  rb_define_method(SwigClassUnderlyingProduct.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingProduct), -1);
  SwigClassUnderlyingProduct.mark = 0;
  SwigClassUnderlyingProduct.destroy = (void (*)(void *)) free_FIX_UnderlyingProduct;
  SwigClassUnderlyingProduct.trackObjects = 0;
  
  SwigClassBenchmarkCurveName.klass = rb_define_class_under(mQuickfix, "BenchmarkCurveName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkCurveName, (void *) &SwigClassBenchmarkCurveName);
  rb_define_alloc_func(SwigClassBenchmarkCurveName.klass, _wrap_BenchmarkCurveName_allocate);
  rb_define_method(SwigClassBenchmarkCurveName.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkCurveName), -1);
  SwigClassBenchmarkCurveName.mark = 0;
  SwigClassBenchmarkCurveName.destroy = (void (*)(void *)) free_FIX_BenchmarkCurveName;
  SwigClassBenchmarkCurveName.trackObjects = 0;
  
  SwigClassUnderlyingSymbolSfx.klass = rb_define_class_under(mQuickfix, "UnderlyingSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSymbolSfx, (void *) &SwigClassUnderlyingSymbolSfx);
  rb_define_alloc_func(SwigClassUnderlyingSymbolSfx.klass, _wrap_UnderlyingSymbolSfx_allocate);
  rb_define_method(SwigClassUnderlyingSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSymbolSfx), -1);
  SwigClassUnderlyingSymbolSfx.mark = 0;
  SwigClassUnderlyingSymbolSfx.destroy = (void (*)(void *)) free_FIX_UnderlyingSymbolSfx;
  SwigClassUnderlyingSymbolSfx.trackObjects = 0;
  
  SwigClassStrikePriceBoundaryPrecision.klass = rb_define_class_under(mQuickfix, "StrikePriceBoundaryPrecision", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision, (void *) &SwigClassStrikePriceBoundaryPrecision);
  rb_define_alloc_func(SwigClassStrikePriceBoundaryPrecision.klass, _wrap_StrikePriceBoundaryPrecision_allocate);
  rb_define_method(SwigClassStrikePriceBoundaryPrecision.klass, "initialize", VALUEFUNC(_wrap_new_StrikePriceBoundaryPrecision), -1);
  SwigClassStrikePriceBoundaryPrecision.mark = 0;
  SwigClassStrikePriceBoundaryPrecision.destroy = (void (*)(void *)) free_FIX_StrikePriceBoundaryPrecision;
  SwigClassStrikePriceBoundaryPrecision.trackObjects = 0;
  
  SwigClassQuoteSetID.klass = rb_define_class_under(mQuickfix, "QuoteSetID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteSetID, (void *) &SwigClassQuoteSetID);
  rb_define_alloc_func(SwigClassQuoteSetID.klass, _wrap_QuoteSetID_allocate);
  rb_define_method(SwigClassQuoteSetID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteSetID), -1);
  SwigClassQuoteSetID.mark = 0;
  SwigClassQuoteSetID.destroy = (void (*)(void *)) free_FIX_QuoteSetID;
  SwigClassQuoteSetID.trackObjects = 0;
  
  SwigClassCashMargin.klass = rb_define_class_under(mQuickfix, "CashMargin", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashMargin, (void *) &SwigClassCashMargin);
  rb_define_alloc_func(SwigClassCashMargin.klass, _wrap_CashMargin_allocate);
  rb_define_method(SwigClassCashMargin.klass, "initialize", VALUEFUNC(_wrap_new_CashMargin), -1);
  SwigClassCashMargin.mark = 0;
  SwigClassCashMargin.destroy = (void (*)(void *)) free_FIX_CashMargin;
  SwigClassCashMargin.trackObjects = 0;
  
  SwigClassSettlObligTransType.klass = rb_define_class_under(mQuickfix, "SettlObligTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligTransType, (void *) &SwigClassSettlObligTransType);
  rb_define_alloc_func(SwigClassSettlObligTransType.klass, _wrap_SettlObligTransType_allocate);
  rb_define_method(SwigClassSettlObligTransType.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligTransType), -1);
  SwigClassSettlObligTransType.mark = 0;
  SwigClassSettlObligTransType.destroy = (void (*)(void *)) free_FIX_SettlObligTransType;
  SwigClassSettlObligTransType.trackObjects = 0;
  
  SwigClassLegNumber.klass = rb_define_class_under(mQuickfix, "LegNumber", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegNumber, (void *) &SwigClassLegNumber);
  rb_define_alloc_func(SwigClassLegNumber.klass, _wrap_LegNumber_allocate);
  rb_define_method(SwigClassLegNumber.klass, "initialize", VALUEFUNC(_wrap_new_LegNumber), -1);
  SwigClassLegNumber.mark = 0;
  SwigClassLegNumber.destroy = (void (*)(void *)) free_FIX_LegNumber;
  SwigClassLegNumber.trackObjects = 0;
  
  SwigClassDeskOrderHandlingInst.klass = rb_define_class_under(mQuickfix, "DeskOrderHandlingInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskOrderHandlingInst, (void *) &SwigClassDeskOrderHandlingInst);
  rb_define_alloc_func(SwigClassDeskOrderHandlingInst.klass, _wrap_DeskOrderHandlingInst_allocate);
  rb_define_method(SwigClassDeskOrderHandlingInst.klass, "initialize", VALUEFUNC(_wrap_new_DeskOrderHandlingInst), -1);
  SwigClassDeskOrderHandlingInst.mark = 0;
  SwigClassDeskOrderHandlingInst.destroy = (void (*)(void *)) free_FIX_DeskOrderHandlingInst;
  SwigClassDeskOrderHandlingInst.trackObjects = 0;
  
  SwigClassSettlPartyIDSource.klass = rb_define_class_under(mQuickfix, "SettlPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartyIDSource, (void *) &SwigClassSettlPartyIDSource);
  rb_define_alloc_func(SwigClassSettlPartyIDSource.klass, _wrap_SettlPartyIDSource_allocate);
  rb_define_method(SwigClassSettlPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartyIDSource), -1);
  SwigClassSettlPartyIDSource.mark = 0;
  SwigClassSettlPartyIDSource.destroy = (void (*)(void *)) free_FIX_SettlPartyIDSource;
  SwigClassSettlPartyIDSource.trackObjects = 0;
  
  SwigClassPriorSettlPrice.klass = rb_define_class_under(mQuickfix, "PriorSettlPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriorSettlPrice, (void *) &SwigClassPriorSettlPrice);
  rb_define_alloc_func(SwigClassPriorSettlPrice.klass, _wrap_PriorSettlPrice_allocate);
  rb_define_method(SwigClassPriorSettlPrice.klass, "initialize", VALUEFUNC(_wrap_new_PriorSettlPrice), -1);
  SwigClassPriorSettlPrice.mark = 0;
  SwigClassPriorSettlPrice.destroy = (void (*)(void *)) free_FIX_PriorSettlPrice;
  SwigClassPriorSettlPrice.trackObjects = 0;
  
  SwigClassNotAffOrigClOrdID.klass = rb_define_class_under(mQuickfix, "NotAffOrigClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotAffOrigClOrdID, (void *) &SwigClassNotAffOrigClOrdID);
  rb_define_alloc_func(SwigClassNotAffOrigClOrdID.klass, _wrap_NotAffOrigClOrdID_allocate);
  rb_define_method(SwigClassNotAffOrigClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_NotAffOrigClOrdID), -1);
  SwigClassNotAffOrigClOrdID.mark = 0;
  SwigClassNotAffOrigClOrdID.destroy = (void (*)(void *)) free_FIX_NotAffOrigClOrdID;
  SwigClassNotAffOrigClOrdID.trackObjects = 0;
  
  SwigClassTradingSessionDesc.klass = rb_define_class_under(mQuickfix, "TradingSessionDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingSessionDesc, (void *) &SwigClassTradingSessionDesc);
  rb_define_alloc_func(SwigClassTradingSessionDesc.klass, _wrap_TradingSessionDesc_allocate);
  rb_define_method(SwigClassTradingSessionDesc.klass, "initialize", VALUEFUNC(_wrap_new_TradingSessionDesc), -1);
  SwigClassTradingSessionDesc.mark = 0;
  SwigClassTradingSessionDesc.destroy = (void (*)(void *)) free_FIX_TradingSessionDesc;
  SwigClassTradingSessionDesc.trackObjects = 0;
  
  SwigClassDerivativeFloorPrice.klass = rb_define_class_under(mQuickfix, "DerivativeFloorPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeFloorPrice, (void *) &SwigClassDerivativeFloorPrice);
  rb_define_alloc_func(SwigClassDerivativeFloorPrice.klass, _wrap_DerivativeFloorPrice_allocate);
  rb_define_method(SwigClassDerivativeFloorPrice.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeFloorPrice), -1);
  SwigClassDerivativeFloorPrice.mark = 0;
  SwigClassDerivativeFloorPrice.destroy = (void (*)(void *)) free_FIX_DerivativeFloorPrice;
  SwigClassDerivativeFloorPrice.trackObjects = 0;
  
  SwigClassDerivativeSymbol.klass = rb_define_class_under(mQuickfix, "DerivativeSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSymbol, (void *) &SwigClassDerivativeSymbol);
  rb_define_alloc_func(SwigClassDerivativeSymbol.klass, _wrap_DerivativeSymbol_allocate);
  rb_define_method(SwigClassDerivativeSymbol.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSymbol), -1);
  SwigClassDerivativeSymbol.mark = 0;
  SwigClassDerivativeSymbol.destroy = (void (*)(void *)) free_FIX_DerivativeSymbol;
  SwigClassDerivativeSymbol.trackObjects = 0;
  
  SwigClassRiskFreeRate.klass = rb_define_class_under(mQuickfix, "RiskFreeRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskFreeRate, (void *) &SwigClassRiskFreeRate);
  rb_define_alloc_func(SwigClassRiskFreeRate.klass, _wrap_RiskFreeRate_allocate);
  rb_define_method(SwigClassRiskFreeRate.klass, "initialize", VALUEFUNC(_wrap_new_RiskFreeRate), -1);
  SwigClassRiskFreeRate.mark = 0;
  SwigClassRiskFreeRate.destroy = (void (*)(void *)) free_FIX_RiskFreeRate;
  SwigClassRiskFreeRate.trackObjects = 0;
  
  SwigClassPosTransType.klass = rb_define_class_under(mQuickfix, "PosTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosTransType, (void *) &SwigClassPosTransType);
  rb_define_alloc_func(SwigClassPosTransType.klass, _wrap_PosTransType_allocate);
  rb_define_method(SwigClassPosTransType.klass, "initialize", VALUEFUNC(_wrap_new_PosTransType), -1);
  SwigClassPosTransType.mark = 0;
  SwigClassPosTransType.destroy = (void (*)(void *)) free_FIX_PosTransType;
  SwigClassPosTransType.trackObjects = 0;
  
  SwigClassMsgSeqNum.klass = rb_define_class_under(mQuickfix, "MsgSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MsgSeqNum, (void *) &SwigClassMsgSeqNum);
  rb_define_alloc_func(SwigClassMsgSeqNum.klass, _wrap_MsgSeqNum_allocate);
  rb_define_method(SwigClassMsgSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_MsgSeqNum), -1);
  SwigClassMsgSeqNum.mark = 0;
  SwigClassMsgSeqNum.destroy = (void (*)(void *)) free_FIX_MsgSeqNum;
  SwigClassMsgSeqNum.trackObjects = 0;
  
  SwigClassSignature.klass = rb_define_class_under(mQuickfix, "Signature", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Signature, (void *) &SwigClassSignature);
  rb_define_alloc_func(SwigClassSignature.klass, _wrap_Signature_allocate);
  rb_define_method(SwigClassSignature.klass, "initialize", VALUEFUNC(_wrap_new_Signature), -1);
  SwigClassSignature.mark = 0;
  SwigClassSignature.destroy = (void (*)(void *)) free_FIX_Signature;
  SwigClassSignature.trackObjects = 0;
  
  SwigClassSeniority.klass = rb_define_class_under(mQuickfix, "Seniority", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Seniority, (void *) &SwigClassSeniority);
  rb_define_alloc_func(SwigClassSeniority.klass, _wrap_Seniority_allocate);
  rb_define_method(SwigClassSeniority.klass, "initialize", VALUEFUNC(_wrap_new_Seniority), -1);
  SwigClassSeniority.mark = 0;
  SwigClassSeniority.destroy = (void (*)(void *)) free_FIX_Seniority;
  SwigClassSeniority.trackObjects = 0;
  
  SwigClassNoRateSources.klass = rb_define_class_under(mQuickfix, "NoRateSources", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRateSources, (void *) &SwigClassNoRateSources);
  rb_define_alloc_func(SwigClassNoRateSources.klass, _wrap_NoRateSources_allocate);
  rb_define_method(SwigClassNoRateSources.klass, "initialize", VALUEFUNC(_wrap_new_NoRateSources), -1);
  SwigClassNoRateSources.mark = 0;
  SwigClassNoRateSources.destroy = (void (*)(void *)) free_FIX_NoRateSources;
  SwigClassNoRateSources.trackObjects = 0;
  
  SwigClassPriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "PriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceUnitOfMeasureQty, (void *) &SwigClassPriceUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassPriceUnitOfMeasureQty.klass, _wrap_PriceUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassPriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_PriceUnitOfMeasureQty), -1);
  SwigClassPriceUnitOfMeasureQty.mark = 0;
  SwigClassPriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_PriceUnitOfMeasureQty;
  SwigClassPriceUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassCollAsgnRefID.klass = rb_define_class_under(mQuickfix, "CollAsgnRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnRefID, (void *) &SwigClassCollAsgnRefID);
  rb_define_alloc_func(SwigClassCollAsgnRefID.klass, _wrap_CollAsgnRefID_allocate);
  rb_define_method(SwigClassCollAsgnRefID.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnRefID), -1);
  SwigClassCollAsgnRefID.mark = 0;
  SwigClassCollAsgnRefID.destroy = (void (*)(void *)) free_FIX_CollAsgnRefID;
  SwigClassCollAsgnRefID.trackObjects = 0;
  
  SwigClassBuyVolume.klass = rb_define_class_under(mQuickfix, "BuyVolume", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BuyVolume, (void *) &SwigClassBuyVolume);
  rb_define_alloc_func(SwigClassBuyVolume.klass, _wrap_BuyVolume_allocate);
  rb_define_method(SwigClassBuyVolume.klass, "initialize", VALUEFUNC(_wrap_new_BuyVolume), -1);
  SwigClassBuyVolume.mark = 0;
  SwigClassBuyVolume.destroy = (void (*)(void *)) free_FIX_BuyVolume;
  SwigClassBuyVolume.trackObjects = 0;
  
  SwigClassSettlCurrFxRateCalc.klass = rb_define_class_under(mQuickfix, "SettlCurrFxRateCalc", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrFxRateCalc, (void *) &SwigClassSettlCurrFxRateCalc);
  rb_define_alloc_func(SwigClassSettlCurrFxRateCalc.klass, _wrap_SettlCurrFxRateCalc_allocate);
  rb_define_method(SwigClassSettlCurrFxRateCalc.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrFxRateCalc), -1);
  SwigClassSettlCurrFxRateCalc.mark = 0;
  SwigClassSettlCurrFxRateCalc.destroy = (void (*)(void *)) free_FIX_SettlCurrFxRateCalc;
  SwigClassSettlCurrFxRateCalc.trackObjects = 0;
  
  SwigClassPosMaintStatus.klass = rb_define_class_under(mQuickfix, "PosMaintStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintStatus, (void *) &SwigClassPosMaintStatus);
  rb_define_alloc_func(SwigClassPosMaintStatus.klass, _wrap_PosMaintStatus_allocate);
  rb_define_method(SwigClassPosMaintStatus.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintStatus), -1);
  SwigClassPosMaintStatus.mark = 0;
  SwigClassPosMaintStatus.destroy = (void (*)(void *)) free_FIX_PosMaintStatus;
  SwigClassPosMaintStatus.trackObjects = 0;
  
  SwigClassPriorSpreadIndicator.klass = rb_define_class_under(mQuickfix, "PriorSpreadIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriorSpreadIndicator, (void *) &SwigClassPriorSpreadIndicator);
  rb_define_alloc_func(SwigClassPriorSpreadIndicator.klass, _wrap_PriorSpreadIndicator_allocate);
  rb_define_method(SwigClassPriorSpreadIndicator.klass, "initialize", VALUEFUNC(_wrap_new_PriorSpreadIndicator), -1);
  SwigClassPriorSpreadIndicator.mark = 0;
  SwigClassPriorSpreadIndicator.destroy = (void (*)(void *)) free_FIX_PriorSpreadIndicator;
  SwigClassPriorSpreadIndicator.trackObjects = 0;
  
  SwigClassBenchmark.klass = rb_define_class_under(mQuickfix, "Benchmark", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Benchmark, (void *) &SwigClassBenchmark);
  rb_define_alloc_func(SwigClassBenchmark.klass, _wrap_Benchmark_allocate);
  rb_define_method(SwigClassBenchmark.klass, "initialize", VALUEFUNC(_wrap_new_Benchmark), -1);
  SwigClassBenchmark.mark = 0;
  SwigClassBenchmark.destroy = (void (*)(void *)) free_FIX_Benchmark;
  SwigClassBenchmark.trackObjects = 0;
  
  SwigClassMaturityMonthYearFormat.klass = rb_define_class_under(mQuickfix, "MaturityMonthYearFormat", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYearFormat, (void *) &SwigClassMaturityMonthYearFormat);
  rb_define_alloc_func(SwigClassMaturityMonthYearFormat.klass, _wrap_MaturityMonthYearFormat_allocate);
  rb_define_method(SwigClassMaturityMonthYearFormat.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYearFormat), -1);
  SwigClassMaturityMonthYearFormat.mark = 0;
  SwigClassMaturityMonthYearFormat.destroy = (void (*)(void *)) free_FIX_MaturityMonthYearFormat;
  SwigClassMaturityMonthYearFormat.trackObjects = 0;
  
  SwigClassUnderlyingTradingSessionID.klass = rb_define_class_under(mQuickfix, "UnderlyingTradingSessionID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingTradingSessionID, (void *) &SwigClassUnderlyingTradingSessionID);
  rb_define_alloc_func(SwigClassUnderlyingTradingSessionID.klass, _wrap_UnderlyingTradingSessionID_allocate);
  rb_define_method(SwigClassUnderlyingTradingSessionID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingTradingSessionID), -1);
  SwigClassUnderlyingTradingSessionID.mark = 0;
  SwigClassUnderlyingTradingSessionID.destroy = (void (*)(void *)) free_FIX_UnderlyingTradingSessionID;
  SwigClassUnderlyingTradingSessionID.trackObjects = 0;
  
  SwigClassTotNoRelatedSym.klass = rb_define_class_under(mQuickfix, "TotNoRelatedSym", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoRelatedSym, (void *) &SwigClassTotNoRelatedSym);
  rb_define_alloc_func(SwigClassTotNoRelatedSym.klass, _wrap_TotNoRelatedSym_allocate);
  rb_define_method(SwigClassTotNoRelatedSym.klass, "initialize", VALUEFUNC(_wrap_new_TotNoRelatedSym), -1);
  SwigClassTotNoRelatedSym.mark = 0;
  SwigClassTotNoRelatedSym.destroy = (void (*)(void *)) free_FIX_TotNoRelatedSym;
  SwigClassTotNoRelatedSym.trackObjects = 0;
  
  SwigClassStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "StateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StateOrProvinceOfIssue, (void *) &SwigClassStateOrProvinceOfIssue);
  rb_define_alloc_func(SwigClassStateOrProvinceOfIssue.klass, _wrap_StateOrProvinceOfIssue_allocate);
  rb_define_method(SwigClassStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_StateOrProvinceOfIssue), -1);
  SwigClassStateOrProvinceOfIssue.mark = 0;
  SwigClassStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_StateOrProvinceOfIssue;
  SwigClassStateOrProvinceOfIssue.trackObjects = 0;
  
  SwigClassDerivativeInstrRegistry.klass = rb_define_class_under(mQuickfix, "DerivativeInstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrRegistry, (void *) &SwigClassDerivativeInstrRegistry);
  rb_define_alloc_func(SwigClassDerivativeInstrRegistry.klass, _wrap_DerivativeInstrRegistry_allocate);
  rb_define_method(SwigClassDerivativeInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrRegistry), -1);
  SwigClassDerivativeInstrRegistry.mark = 0;
  SwigClassDerivativeInstrRegistry.destroy = (void (*)(void *)) free_FIX_DerivativeInstrRegistry;
  SwigClassDerivativeInstrRegistry.trackObjects = 0;
  
  SwigClassLegBidForwardPoints.klass = rb_define_class_under(mQuickfix, "LegBidForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBidForwardPoints, (void *) &SwigClassLegBidForwardPoints);
  rb_define_alloc_func(SwigClassLegBidForwardPoints.klass, _wrap_LegBidForwardPoints_allocate);
  rb_define_method(SwigClassLegBidForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LegBidForwardPoints), -1);
  SwigClassLegBidForwardPoints.mark = 0;
  SwigClassLegBidForwardPoints.destroy = (void (*)(void *)) free_FIX_LegBidForwardPoints;
  SwigClassLegBidForwardPoints.trackObjects = 0;
  
  SwigClassManualOrderIndicator.klass = rb_define_class_under(mQuickfix, "ManualOrderIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ManualOrderIndicator, (void *) &SwigClassManualOrderIndicator);
  rb_define_alloc_func(SwigClassManualOrderIndicator.klass, _wrap_ManualOrderIndicator_allocate);
  rb_define_method(SwigClassManualOrderIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ManualOrderIndicator), -1);
  SwigClassManualOrderIndicator.mark = 0;
  SwigClassManualOrderIndicator.destroy = (void (*)(void *)) free_FIX_ManualOrderIndicator;
  SwigClassManualOrderIndicator.trackObjects = 0;
  
  SwigClassNetMoney.klass = rb_define_class_under(mQuickfix, "NetMoney", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetMoney, (void *) &SwigClassNetMoney);
  rb_define_alloc_func(SwigClassNetMoney.klass, _wrap_NetMoney_allocate);
  rb_define_method(SwigClassNetMoney.klass, "initialize", VALUEFUNC(_wrap_new_NetMoney), -1);
  SwigClassNetMoney.mark = 0;
  SwigClassNetMoney.destroy = (void (*)(void *)) free_FIX_NetMoney;
  SwigClassNetMoney.trackObjects = 0;
  
  SwigClassLegalConfirm.klass = rb_define_class_under(mQuickfix, "LegalConfirm", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegalConfirm, (void *) &SwigClassLegalConfirm);
  rb_define_alloc_func(SwigClassLegalConfirm.klass, _wrap_LegalConfirm_allocate);
  rb_define_method(SwigClassLegalConfirm.klass, "initialize", VALUEFUNC(_wrap_new_LegalConfirm), -1);
  SwigClassLegalConfirm.mark = 0;
  SwigClassLegalConfirm.destroy = (void (*)(void *)) free_FIX_LegalConfirm;
  SwigClassLegalConfirm.trackObjects = 0;
  
  SwigClassCountryOfIssue.klass = rb_define_class_under(mQuickfix, "CountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CountryOfIssue, (void *) &SwigClassCountryOfIssue);
  rb_define_alloc_func(SwigClassCountryOfIssue.klass, _wrap_CountryOfIssue_allocate);
  rb_define_method(SwigClassCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_CountryOfIssue), -1);
  SwigClassCountryOfIssue.mark = 0;
  SwigClassCountryOfIssue.destroy = (void (*)(void *)) free_FIX_CountryOfIssue;
  SwigClassCountryOfIssue.trackObjects = 0;
  
  SwigClassApplReportType.klass = rb_define_class_under(mQuickfix, "ApplReportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReportType, (void *) &SwigClassApplReportType);
  rb_define_alloc_func(SwigClassApplReportType.klass, _wrap_ApplReportType_allocate);
  rb_define_method(SwigClassApplReportType.klass, "initialize", VALUEFUNC(_wrap_new_ApplReportType), -1);
  SwigClassApplReportType.mark = 0;
  SwigClassApplReportType.destroy = (void (*)(void *)) free_FIX_ApplReportType;
  SwigClassApplReportType.trackObjects = 0;
  
  SwigClassRootPartyID.klass = rb_define_class_under(mQuickfix, "RootPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartyID, (void *) &SwigClassRootPartyID);
  rb_define_alloc_func(SwigClassRootPartyID.klass, _wrap_RootPartyID_allocate);
  rb_define_method(SwigClassRootPartyID.klass, "initialize", VALUEFUNC(_wrap_new_RootPartyID), -1);
  SwigClassRootPartyID.mark = 0;
  SwigClassRootPartyID.destroy = (void (*)(void *)) free_FIX_RootPartyID;
  SwigClassRootPartyID.trackObjects = 0;
  
  SwigClassUnderlyingQty.klass = rb_define_class_under(mQuickfix, "UnderlyingQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingQty, (void *) &SwigClassUnderlyingQty);
  rb_define_alloc_func(SwigClassUnderlyingQty.klass, _wrap_UnderlyingQty_allocate);
  rb_define_method(SwigClassUnderlyingQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingQty), -1);
  SwigClassUnderlyingQty.mark = 0;
  SwigClassUnderlyingQty.destroy = (void (*)(void *)) free_FIX_UnderlyingQty;
  SwigClassUnderlyingQty.trackObjects = 0;
  
  SwigClassApplQueueDepth.klass = rb_define_class_under(mQuickfix, "ApplQueueDepth", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueDepth, (void *) &SwigClassApplQueueDepth);
  rb_define_alloc_func(SwigClassApplQueueDepth.klass, _wrap_ApplQueueDepth_allocate);
  rb_define_method(SwigClassApplQueueDepth.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueDepth), -1);
  SwigClassApplQueueDepth.mark = 0;
  SwigClassApplQueueDepth.destroy = (void (*)(void *)) free_FIX_ApplQueueDepth;
  SwigClassApplQueueDepth.trackObjects = 0;
  
  SwigClassStopPx.klass = rb_define_class_under(mQuickfix, "StopPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StopPx, (void *) &SwigClassStopPx);
  rb_define_alloc_func(SwigClassStopPx.klass, _wrap_StopPx_allocate);
  rb_define_method(SwigClassStopPx.klass, "initialize", VALUEFUNC(_wrap_new_StopPx), -1);
  SwigClassStopPx.mark = 0;
  SwigClassStopPx.destroy = (void (*)(void *)) free_FIX_StopPx;
  SwigClassStopPx.trackObjects = 0;
  
  SwigClassReportToExch.klass = rb_define_class_under(mQuickfix, "ReportToExch", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReportToExch, (void *) &SwigClassReportToExch);
  rb_define_alloc_func(SwigClassReportToExch.klass, _wrap_ReportToExch_allocate);
  rb_define_method(SwigClassReportToExch.klass, "initialize", VALUEFUNC(_wrap_new_ReportToExch), -1);
  SwigClassReportToExch.mark = 0;
  SwigClassReportToExch.destroy = (void (*)(void *)) free_FIX_ReportToExch;
  SwigClassReportToExch.trackObjects = 0;
  
  SwigClassContraryInstructionIndicator.klass = rb_define_class_under(mQuickfix, "ContraryInstructionIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraryInstructionIndicator, (void *) &SwigClassContraryInstructionIndicator);
  rb_define_alloc_func(SwigClassContraryInstructionIndicator.klass, _wrap_ContraryInstructionIndicator_allocate);
  rb_define_method(SwigClassContraryInstructionIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ContraryInstructionIndicator), -1);
  SwigClassContraryInstructionIndicator.mark = 0;
  SwigClassContraryInstructionIndicator.destroy = (void (*)(void *)) free_FIX_ContraryInstructionIndicator;
  SwigClassContraryInstructionIndicator.trackObjects = 0;
  
  SwigClassEncodedListStatusTextLen.klass = rb_define_class_under(mQuickfix, "EncodedListStatusTextLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListStatusTextLen, (void *) &SwigClassEncodedListStatusTextLen);
  rb_define_alloc_func(SwigClassEncodedListStatusTextLen.klass, _wrap_EncodedListStatusTextLen_allocate);
  rb_define_method(SwigClassEncodedListStatusTextLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListStatusTextLen), -1);
  SwigClassEncodedListStatusTextLen.mark = 0;
  SwigClassEncodedListStatusTextLen.destroy = (void (*)(void *)) free_FIX_EncodedListStatusTextLen;
  SwigClassEncodedListStatusTextLen.trackObjects = 0;
  
  SwigClassDerivativeSecurityXMLSchema.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityXMLSchema", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema, (void *) &SwigClassDerivativeSecurityXMLSchema);
  rb_define_alloc_func(SwigClassDerivativeSecurityXMLSchema.klass, _wrap_DerivativeSecurityXMLSchema_allocate);
  rb_define_method(SwigClassDerivativeSecurityXMLSchema.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityXMLSchema), -1);
  SwigClassDerivativeSecurityXMLSchema.mark = 0;
  SwigClassDerivativeSecurityXMLSchema.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityXMLSchema;
  SwigClassDerivativeSecurityXMLSchema.trackObjects = 0;
  
  SwigClassNoRelatedSym.klass = rb_define_class_under(mQuickfix, "NoRelatedSym", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedSym, (void *) &SwigClassNoRelatedSym);
  rb_define_alloc_func(SwigClassNoRelatedSym.klass, _wrap_NoRelatedSym_allocate);
  rb_define_method(SwigClassNoRelatedSym.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedSym), -1);
  SwigClassNoRelatedSym.mark = 0;
  SwigClassNoRelatedSym.destroy = (void (*)(void *)) free_FIX_NoRelatedSym;
  SwigClassNoRelatedSym.trackObjects = 0;
  
  SwigClassAllocRejCode.klass = rb_define_class_under(mQuickfix, "AllocRejCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocRejCode, (void *) &SwigClassAllocRejCode);
  rb_define_alloc_func(SwigClassAllocRejCode.klass, _wrap_AllocRejCode_allocate);
  rb_define_method(SwigClassAllocRejCode.klass, "initialize", VALUEFUNC(_wrap_new_AllocRejCode), -1);
  SwigClassAllocRejCode.mark = 0;
  SwigClassAllocRejCode.destroy = (void (*)(void *)) free_FIX_AllocRejCode;
  SwigClassAllocRejCode.trackObjects = 0;
  
  SwigClassUnderlyingSecurityAltID.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityAltID, (void *) &SwigClassUnderlyingSecurityAltID);
  rb_define_alloc_func(SwigClassUnderlyingSecurityAltID.klass, _wrap_UnderlyingSecurityAltID_allocate);
  rb_define_method(SwigClassUnderlyingSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityAltID), -1);
  SwigClassUnderlyingSecurityAltID.mark = 0;
  SwigClassUnderlyingSecurityAltID.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityAltID;
  SwigClassUnderlyingSecurityAltID.trackObjects = 0;
  
  SwigClassRefOrdIDReason.klass = rb_define_class_under(mQuickfix, "RefOrdIDReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefOrdIDReason, (void *) &SwigClassRefOrdIDReason);
  rb_define_alloc_func(SwigClassRefOrdIDReason.klass, _wrap_RefOrdIDReason_allocate);
  rb_define_method(SwigClassRefOrdIDReason.klass, "initialize", VALUEFUNC(_wrap_new_RefOrdIDReason), -1);
  SwigClassRefOrdIDReason.mark = 0;
  SwigClassRefOrdIDReason.destroy = (void (*)(void *)) free_FIX_RefOrdIDReason;
  SwigClassRefOrdIDReason.trackObjects = 0;
  
  SwigClassDerivativeInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyID, (void *) &SwigClassDerivativeInstrumentPartyID);
  rb_define_alloc_func(SwigClassDerivativeInstrumentPartyID.klass, _wrap_DerivativeInstrumentPartyID_allocate);
  rb_define_method(SwigClassDerivativeInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartyID), -1);
  SwigClassDerivativeInstrumentPartyID.mark = 0;
  SwigClassDerivativeInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartyID;
  SwigClassDerivativeInstrumentPartyID.trackObjects = 0;
  
  SwigClassSecurityXMLSchema.klass = rb_define_class_under(mQuickfix, "SecurityXMLSchema", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityXMLSchema, (void *) &SwigClassSecurityXMLSchema);
  rb_define_alloc_func(SwigClassSecurityXMLSchema.klass, _wrap_SecurityXMLSchema_allocate);
  rb_define_method(SwigClassSecurityXMLSchema.klass, "initialize", VALUEFUNC(_wrap_new_SecurityXMLSchema), -1);
  SwigClassSecurityXMLSchema.mark = 0;
  SwigClassSecurityXMLSchema.destroy = (void (*)(void *)) free_FIX_SecurityXMLSchema;
  SwigClassSecurityXMLSchema.trackObjects = 0;
  
  SwigClassRefOrderIDSource.klass = rb_define_class_under(mQuickfix, "RefOrderIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefOrderIDSource, (void *) &SwigClassRefOrderIDSource);
  rb_define_alloc_func(SwigClassRefOrderIDSource.klass, _wrap_RefOrderIDSource_allocate);
  rb_define_method(SwigClassRefOrderIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RefOrderIDSource), -1);
  SwigClassRefOrderIDSource.mark = 0;
  SwigClassRefOrderIDSource.destroy = (void (*)(void *)) free_FIX_RefOrderIDSource;
  SwigClassRefOrderIDSource.trackObjects = 0;
  
  SwigClassNTPositionLimit.klass = rb_define_class_under(mQuickfix, "NTPositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NTPositionLimit, (void *) &SwigClassNTPositionLimit);
  rb_define_alloc_func(SwigClassNTPositionLimit.klass, _wrap_NTPositionLimit_allocate);
  rb_define_method(SwigClassNTPositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_NTPositionLimit), -1);
  SwigClassNTPositionLimit.mark = 0;
  SwigClassNTPositionLimit.destroy = (void (*)(void *)) free_FIX_NTPositionLimit;
  SwigClassNTPositionLimit.trackObjects = 0;
  
  SwigClassEndAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "EndAccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndAccruedInterestAmt, (void *) &SwigClassEndAccruedInterestAmt);
  rb_define_alloc_func(SwigClassEndAccruedInterestAmt.klass, _wrap_EndAccruedInterestAmt_allocate);
  rb_define_method(SwigClassEndAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_EndAccruedInterestAmt), -1);
  SwigClassEndAccruedInterestAmt.mark = 0;
  SwigClassEndAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_EndAccruedInterestAmt;
  SwigClassEndAccruedInterestAmt.trackObjects = 0;
  
  SwigClassAccruedInterestRate.klass = rb_define_class_under(mQuickfix, "AccruedInterestRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AccruedInterestRate, (void *) &SwigClassAccruedInterestRate);
  rb_define_alloc_func(SwigClassAccruedInterestRate.klass, _wrap_AccruedInterestRate_allocate);
  rb_define_method(SwigClassAccruedInterestRate.klass, "initialize", VALUEFUNC(_wrap_new_AccruedInterestRate), -1);
  SwigClassAccruedInterestRate.mark = 0;
  SwigClassAccruedInterestRate.destroy = (void (*)(void *)) free_FIX_AccruedInterestRate;
  SwigClassAccruedInterestRate.trackObjects = 0;
  
  SwigClassLastCapacity.klass = rb_define_class_under(mQuickfix, "LastCapacity", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastCapacity, (void *) &SwigClassLastCapacity);
  rb_define_alloc_func(SwigClassLastCapacity.klass, _wrap_LastCapacity_allocate);
  rb_define_method(SwigClassLastCapacity.klass, "initialize", VALUEFUNC(_wrap_new_LastCapacity), -1);
  SwigClassLastCapacity.mark = 0;
  SwigClassLastCapacity.destroy = (void (*)(void *)) free_FIX_LastCapacity;
  SwigClassLastCapacity.trackObjects = 0;
  
  SwigClassUnderlyingInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID, (void *) &SwigClassUnderlyingInstrumentPartySubID);
  rb_define_alloc_func(SwigClassUnderlyingInstrumentPartySubID.klass, _wrap_UnderlyingInstrumentPartySubID_allocate);
  rb_define_method(SwigClassUnderlyingInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartySubID), -1);
  SwigClassUnderlyingInstrumentPartySubID.mark = 0;
  SwigClassUnderlyingInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartySubID;
  SwigClassUnderlyingInstrumentPartySubID.trackObjects = 0;
  
  SwigClassNoFills.klass = rb_define_class_under(mQuickfix, "NoFills", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoFills, (void *) &SwigClassNoFills);
  rb_define_alloc_func(SwigClassNoFills.klass, _wrap_NoFills_allocate);
  rb_define_method(SwigClassNoFills.klass, "initialize", VALUEFUNC(_wrap_new_NoFills), -1);
  SwigClassNoFills.mark = 0;
  SwigClassNoFills.destroy = (void (*)(void *)) free_FIX_NoFills;
  SwigClassNoFills.trackObjects = 0;
  
  SwigClassNoOrdTypeRules.klass = rb_define_class_under(mQuickfix, "NoOrdTypeRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOrdTypeRules, (void *) &SwigClassNoOrdTypeRules);
  rb_define_alloc_func(SwigClassNoOrdTypeRules.klass, _wrap_NoOrdTypeRules_allocate);
  rb_define_method(SwigClassNoOrdTypeRules.klass, "initialize", VALUEFUNC(_wrap_new_NoOrdTypeRules), -1);
  SwigClassNoOrdTypeRules.mark = 0;
  SwigClassNoOrdTypeRules.destroy = (void (*)(void *)) free_FIX_NoOrdTypeRules;
  SwigClassNoOrdTypeRules.trackObjects = 0;
  
  SwigClassInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "InstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartyID, (void *) &SwigClassInstrumentPartyID);
  rb_define_alloc_func(SwigClassInstrumentPartyID.klass, _wrap_InstrumentPartyID_allocate);
  rb_define_method(SwigClassInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartyID), -1);
  SwigClassInstrumentPartyID.mark = 0;
  SwigClassInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_InstrumentPartyID;
  SwigClassInstrumentPartyID.trackObjects = 0;
  
  SwigClassMarginRatio.klass = rb_define_class_under(mQuickfix, "MarginRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarginRatio, (void *) &SwigClassMarginRatio);
  rb_define_alloc_func(SwigClassMarginRatio.klass, _wrap_MarginRatio_allocate);
  rb_define_method(SwigClassMarginRatio.klass, "initialize", VALUEFUNC(_wrap_new_MarginRatio), -1);
  SwigClassMarginRatio.mark = 0;
  SwigClassMarginRatio.destroy = (void (*)(void *)) free_FIX_MarginRatio;
  SwigClassMarginRatio.trackObjects = 0;
  
  SwigClassRefTagID.klass = rb_define_class_under(mQuickfix, "RefTagID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefTagID, (void *) &SwigClassRefTagID);
  rb_define_alloc_func(SwigClassRefTagID.klass, _wrap_RefTagID_allocate);
  rb_define_method(SwigClassRefTagID.klass, "initialize", VALUEFUNC(_wrap_new_RefTagID), -1);
  SwigClassRefTagID.mark = 0;
  SwigClassRefTagID.destroy = (void (*)(void *)) free_FIX_RefTagID;
  SwigClassRefTagID.trackObjects = 0;
  
  SwigClassNoRoutingIDs.klass = rb_define_class_under(mQuickfix, "NoRoutingIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRoutingIDs, (void *) &SwigClassNoRoutingIDs);
  rb_define_alloc_func(SwigClassNoRoutingIDs.klass, _wrap_NoRoutingIDs_allocate);
  rb_define_method(SwigClassNoRoutingIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRoutingIDs), -1);
  SwigClassNoRoutingIDs.mark = 0;
  SwigClassNoRoutingIDs.destroy = (void (*)(void *)) free_FIX_NoRoutingIDs;
  SwigClassNoRoutingIDs.trackObjects = 0;
  
  SwigClassCouponRate.klass = rb_define_class_under(mQuickfix, "CouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CouponRate, (void *) &SwigClassCouponRate);
  rb_define_alloc_func(SwigClassCouponRate.klass, _wrap_CouponRate_allocate);
  rb_define_method(SwigClassCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_CouponRate), -1);
  SwigClassCouponRate.mark = 0;
  SwigClassCouponRate.destroy = (void (*)(void *)) free_FIX_CouponRate;
  SwigClassCouponRate.trackObjects = 0;
  
  SwigClassNoApplIDs.klass = rb_define_class_under(mQuickfix, "NoApplIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoApplIDs, (void *) &SwigClassNoApplIDs);
  rb_define_alloc_func(SwigClassNoApplIDs.klass, _wrap_NoApplIDs_allocate);
  rb_define_method(SwigClassNoApplIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoApplIDs), -1);
  SwigClassNoApplIDs.mark = 0;
  SwigClassNoApplIDs.destroy = (void (*)(void *)) free_FIX_NoApplIDs;
  SwigClassNoApplIDs.trackObjects = 0;
  
  SwigClassDerivativeContractSettlMonth.klass = rb_define_class_under(mQuickfix, "DerivativeContractSettlMonth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeContractSettlMonth, (void *) &SwigClassDerivativeContractSettlMonth);
  rb_define_alloc_func(SwigClassDerivativeContractSettlMonth.klass, _wrap_DerivativeContractSettlMonth_allocate);
  rb_define_method(SwigClassDerivativeContractSettlMonth.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeContractSettlMonth), -1);
  SwigClassDerivativeContractSettlMonth.mark = 0;
  SwigClassDerivativeContractSettlMonth.destroy = (void (*)(void *)) free_FIX_DerivativeContractSettlMonth;
  SwigClassDerivativeContractSettlMonth.trackObjects = 0;
  
  SwigClassInstrAttribType.klass = rb_define_class_under(mQuickfix, "InstrAttribType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrAttribType, (void *) &SwigClassInstrAttribType);
  rb_define_alloc_func(SwigClassInstrAttribType.klass, _wrap_InstrAttribType_allocate);
  rb_define_method(SwigClassInstrAttribType.klass, "initialize", VALUEFUNC(_wrap_new_InstrAttribType), -1);
  SwigClassInstrAttribType.mark = 0;
  SwigClassInstrAttribType.destroy = (void (*)(void *)) free_FIX_InstrAttribType;
  SwigClassInstrAttribType.trackObjects = 0;
  
  SwigClassProduct.klass = rb_define_class_under(mQuickfix, "Product", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Product, (void *) &SwigClassProduct);
  rb_define_alloc_func(SwigClassProduct.klass, _wrap_Product_allocate);
  rb_define_method(SwigClassProduct.klass, "initialize", VALUEFUNC(_wrap_new_Product), -1);
  SwigClassProduct.mark = 0;
  SwigClassProduct.destroy = (void (*)(void *)) free_FIX_Product;
  SwigClassProduct.trackObjects = 0;
  
  SwigClassAllocShares.klass = rb_define_class_under(mQuickfix, "AllocShares", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocShares, (void *) &SwigClassAllocShares);
  rb_define_alloc_func(SwigClassAllocShares.klass, _wrap_AllocShares_allocate);
  rb_define_method(SwigClassAllocShares.klass, "initialize", VALUEFUNC(_wrap_new_AllocShares), -1);
  SwigClassAllocShares.mark = 0;
  SwigClassAllocShares.destroy = (void (*)(void *)) free_FIX_AllocShares;
  SwigClassAllocShares.trackObjects = 0;
  
  SwigClassNoQuoteEntries.klass = rb_define_class_under(mQuickfix, "NoQuoteEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoQuoteEntries, (void *) &SwigClassNoQuoteEntries);
  rb_define_alloc_func(SwigClassNoQuoteEntries.klass, _wrap_NoQuoteEntries_allocate);
  rb_define_method(SwigClassNoQuoteEntries.klass, "initialize", VALUEFUNC(_wrap_new_NoQuoteEntries), -1);
  SwigClassNoQuoteEntries.mark = 0;
  SwigClassNoQuoteEntries.destroy = (void (*)(void *)) free_FIX_NoQuoteEntries;
  SwigClassNoQuoteEntries.trackObjects = 0;
  
  SwigClassDefaultCstmApplVerID.klass = rb_define_class_under(mQuickfix, "DefaultCstmApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultCstmApplVerID, (void *) &SwigClassDefaultCstmApplVerID);
  rb_define_alloc_func(SwigClassDefaultCstmApplVerID.klass, _wrap_DefaultCstmApplVerID_allocate);
  rb_define_method(SwigClassDefaultCstmApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_DefaultCstmApplVerID), -1);
  SwigClassDefaultCstmApplVerID.mark = 0;
  SwigClassDefaultCstmApplVerID.destroy = (void (*)(void *)) free_FIX_DefaultCstmApplVerID;
  SwigClassDefaultCstmApplVerID.trackObjects = 0;
  
  SwigClassDerivativeListMethod.klass = rb_define_class_under(mQuickfix, "DerivativeListMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeListMethod, (void *) &SwigClassDerivativeListMethod);
  rb_define_alloc_func(SwigClassDerivativeListMethod.klass, _wrap_DerivativeListMethod_allocate);
  rb_define_method(SwigClassDerivativeListMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeListMethod), -1);
  SwigClassDerivativeListMethod.mark = 0;
  SwigClassDerivativeListMethod.destroy = (void (*)(void *)) free_FIX_DerivativeListMethod;
  SwigClassDerivativeListMethod.trackObjects = 0;
  
  SwigClassDerivativeSecurityXMLLen.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityXMLLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityXMLLen, (void *) &SwigClassDerivativeSecurityXMLLen);
  rb_define_alloc_func(SwigClassDerivativeSecurityXMLLen.klass, _wrap_DerivativeSecurityXMLLen_allocate);
  rb_define_method(SwigClassDerivativeSecurityXMLLen.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityXMLLen), -1);
  SwigClassDerivativeSecurityXMLLen.mark = 0;
  SwigClassDerivativeSecurityXMLLen.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityXMLLen;
  SwigClassDerivativeSecurityXMLLen.trackObjects = 0;
  
  SwigClassLegDatedDate.klass = rb_define_class_under(mQuickfix, "LegDatedDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegDatedDate, (void *) &SwigClassLegDatedDate);
  rb_define_alloc_func(SwigClassLegDatedDate.klass, _wrap_LegDatedDate_allocate);
  rb_define_method(SwigClassLegDatedDate.klass, "initialize", VALUEFUNC(_wrap_new_LegDatedDate), -1);
  SwigClassLegDatedDate.mark = 0;
  SwigClassLegDatedDate.destroy = (void (*)(void *)) free_FIX_LegDatedDate;
  SwigClassLegDatedDate.trackObjects = 0;
  
  SwigClassNested2PartyIDSource.klass = rb_define_class_under(mQuickfix, "Nested2PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartyIDSource, (void *) &SwigClassNested2PartyIDSource);
  rb_define_alloc_func(SwigClassNested2PartyIDSource.klass, _wrap_Nested2PartyIDSource_allocate);
  rb_define_method(SwigClassNested2PartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartyIDSource), -1);
  SwigClassNested2PartyIDSource.mark = 0;
  SwigClassNested2PartyIDSource.destroy = (void (*)(void *)) free_FIX_Nested2PartyIDSource;
  SwigClassNested2PartyIDSource.trackObjects = 0;
  
  SwigClassUnderlyingInstrRegistry.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrRegistry, (void *) &SwigClassUnderlyingInstrRegistry);
  rb_define_alloc_func(SwigClassUnderlyingInstrRegistry.klass, _wrap_UnderlyingInstrRegistry_allocate);
  rb_define_method(SwigClassUnderlyingInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrRegistry), -1);
  SwigClassUnderlyingInstrRegistry.mark = 0;
  SwigClassUnderlyingInstrRegistry.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrRegistry;
  SwigClassUnderlyingInstrRegistry.trackObjects = 0;
  
  SwigClassIssueDate.klass = rb_define_class_under(mQuickfix, "IssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IssueDate, (void *) &SwigClassIssueDate);
  rb_define_alloc_func(SwigClassIssueDate.klass, _wrap_IssueDate_allocate);
  rb_define_method(SwigClassIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_IssueDate), -1);
  SwigClassIssueDate.mark = 0;
  SwigClassIssueDate.destroy = (void (*)(void *)) free_FIX_IssueDate;
  SwigClassIssueDate.trackObjects = 0;
  
  SwigClassSecurityTradingStatus.klass = rb_define_class_under(mQuickfix, "SecurityTradingStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityTradingStatus, (void *) &SwigClassSecurityTradingStatus);
  rb_define_alloc_func(SwigClassSecurityTradingStatus.klass, _wrap_SecurityTradingStatus_allocate);
  rb_define_method(SwigClassSecurityTradingStatus.klass, "initialize", VALUEFUNC(_wrap_new_SecurityTradingStatus), -1);
  SwigClassSecurityTradingStatus.mark = 0;
  SwigClassSecurityTradingStatus.destroy = (void (*)(void *)) free_FIX_SecurityTradingStatus;
  SwigClassSecurityTradingStatus.trackObjects = 0;
  
  SwigClassLegOptAttribute.klass = rb_define_class_under(mQuickfix, "LegOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOptAttribute, (void *) &SwigClassLegOptAttribute);
  rb_define_alloc_func(SwigClassLegOptAttribute.klass, _wrap_LegOptAttribute_allocate);
  rb_define_method(SwigClassLegOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_LegOptAttribute), -1);
  SwigClassLegOptAttribute.mark = 0;
  SwigClassLegOptAttribute.destroy = (void (*)(void *)) free_FIX_LegOptAttribute;
  SwigClassLegOptAttribute.trackObjects = 0;
  
  SwigClassMaxFloor.klass = rb_define_class_under(mQuickfix, "MaxFloor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxFloor, (void *) &SwigClassMaxFloor);
  rb_define_alloc_func(SwigClassMaxFloor.klass, _wrap_MaxFloor_allocate);
  rb_define_method(SwigClassMaxFloor.klass, "initialize", VALUEFUNC(_wrap_new_MaxFloor), -1);
  SwigClassMaxFloor.mark = 0;
  SwigClassMaxFloor.destroy = (void (*)(void *)) free_FIX_MaxFloor;
  SwigClassMaxFloor.trackObjects = 0;
  
  SwigClassDerivativeLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "DerivativeLocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeLocaleOfIssue, (void *) &SwigClassDerivativeLocaleOfIssue);
  rb_define_alloc_func(SwigClassDerivativeLocaleOfIssue.klass, _wrap_DerivativeLocaleOfIssue_allocate);
  rb_define_method(SwigClassDerivativeLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeLocaleOfIssue), -1);
  SwigClassDerivativeLocaleOfIssue.mark = 0;
  SwigClassDerivativeLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_DerivativeLocaleOfIssue;
  SwigClassDerivativeLocaleOfIssue.trackObjects = 0;
  
  SwigClassOptPayAmount.klass = rb_define_class_under(mQuickfix, "OptPayAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptPayAmount, (void *) &SwigClassOptPayAmount);
  rb_define_alloc_func(SwigClassOptPayAmount.klass, _wrap_OptPayAmount_allocate);
  rb_define_method(SwigClassOptPayAmount.klass, "initialize", VALUEFUNC(_wrap_new_OptPayAmount), -1);
  SwigClassOptPayAmount.mark = 0;
  SwigClassOptPayAmount.destroy = (void (*)(void *)) free_FIX_OptPayAmount;
  SwigClassOptPayAmount.trackObjects = 0;
  
  SwigClassUnderlyingStipType.klass = rb_define_class_under(mQuickfix, "UnderlyingStipType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStipType, (void *) &SwigClassUnderlyingStipType);
  rb_define_alloc_func(SwigClassUnderlyingStipType.klass, _wrap_UnderlyingStipType_allocate);
  rb_define_method(SwigClassUnderlyingStipType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStipType), -1);
  SwigClassUnderlyingStipType.mark = 0;
  SwigClassUnderlyingStipType.destroy = (void (*)(void *)) free_FIX_UnderlyingStipType;
  SwigClassUnderlyingStipType.trackObjects = 0;
  
  SwigClassRule80A.klass = rb_define_class_under(mQuickfix, "Rule80A", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Rule80A, (void *) &SwigClassRule80A);
  rb_define_alloc_func(SwigClassRule80A.klass, _wrap_Rule80A_allocate);
  rb_define_method(SwigClassRule80A.klass, "initialize", VALUEFUNC(_wrap_new_Rule80A), -1);
  SwigClassRule80A.mark = 0;
  SwigClassRule80A.destroy = (void (*)(void *)) free_FIX_Rule80A;
  SwigClassRule80A.trackObjects = 0;
  
  SwigClassTotNoStrikes.klass = rb_define_class_under(mQuickfix, "TotNoStrikes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoStrikes, (void *) &SwigClassTotNoStrikes);
  rb_define_alloc_func(SwigClassTotNoStrikes.klass, _wrap_TotNoStrikes_allocate);
  rb_define_method(SwigClassTotNoStrikes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoStrikes), -1);
  SwigClassTotNoStrikes.mark = 0;
  SwigClassTotNoStrikes.destroy = (void (*)(void *)) free_FIX_TotNoStrikes;
  SwigClassTotNoStrikes.trackObjects = 0;
  
  SwigClassCorporateAction.klass = rb_define_class_under(mQuickfix, "CorporateAction", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CorporateAction, (void *) &SwigClassCorporateAction);
  rb_define_alloc_func(SwigClassCorporateAction.klass, _wrap_CorporateAction_allocate);
  rb_define_method(SwigClassCorporateAction.klass, "initialize", VALUEFUNC(_wrap_new_CorporateAction), -1);
  SwigClassCorporateAction.mark = 0;
  SwigClassCorporateAction.destroy = (void (*)(void *)) free_FIX_CorporateAction;
  SwigClassCorporateAction.trackObjects = 0;
  
  SwigClassTerminationType.klass = rb_define_class_under(mQuickfix, "TerminationType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TerminationType, (void *) &SwigClassTerminationType);
  rb_define_alloc_func(SwigClassTerminationType.klass, _wrap_TerminationType_allocate);
  rb_define_method(SwigClassTerminationType.klass, "initialize", VALUEFUNC(_wrap_new_TerminationType), -1);
  SwigClassTerminationType.mark = 0;
  SwigClassTerminationType.destroy = (void (*)(void *)) free_FIX_TerminationType;
  SwigClassTerminationType.trackObjects = 0;
  
  SwigClassLegCouponRate.klass = rb_define_class_under(mQuickfix, "LegCouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCouponRate, (void *) &SwigClassLegCouponRate);
  rb_define_alloc_func(SwigClassLegCouponRate.klass, _wrap_LegCouponRate_allocate);
  rb_define_method(SwigClassLegCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_LegCouponRate), -1);
  SwigClassLegCouponRate.mark = 0;
  SwigClassLegCouponRate.destroy = (void (*)(void *)) free_FIX_LegCouponRate;
  SwigClassLegCouponRate.trackObjects = 0;
  
  SwigClassPosMaintAction.klass = rb_define_class_under(mQuickfix, "PosMaintAction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintAction, (void *) &SwigClassPosMaintAction);
  rb_define_alloc_func(SwigClassPosMaintAction.klass, _wrap_PosMaintAction_allocate);
  rb_define_method(SwigClassPosMaintAction.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintAction), -1);
  SwigClassPosMaintAction.mark = 0;
  SwigClassPosMaintAction.destroy = (void (*)(void *)) free_FIX_PosMaintAction;
  SwigClassPosMaintAction.trackObjects = 0;
  
  SwigClassNoSecurityTypes.klass = rb_define_class_under(mQuickfix, "NoSecurityTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSecurityTypes, (void *) &SwigClassNoSecurityTypes);
  rb_define_alloc_func(SwigClassNoSecurityTypes.klass, _wrap_NoSecurityTypes_allocate);
  rb_define_method(SwigClassNoSecurityTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoSecurityTypes), -1);
  SwigClassNoSecurityTypes.mark = 0;
  SwigClassNoSecurityTypes.destroy = (void (*)(void *)) free_FIX_NoSecurityTypes;
  SwigClassNoSecurityTypes.trackObjects = 0;
  
  SwigClassComplexEventPriceTimeType.klass = rb_define_class_under(mQuickfix, "ComplexEventPriceTimeType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPriceTimeType, (void *) &SwigClassComplexEventPriceTimeType);
  rb_define_alloc_func(SwigClassComplexEventPriceTimeType.klass, _wrap_ComplexEventPriceTimeType_allocate);
  rb_define_method(SwigClassComplexEventPriceTimeType.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPriceTimeType), -1);
  SwigClassComplexEventPriceTimeType.mark = 0;
  SwigClassComplexEventPriceTimeType.destroy = (void (*)(void *)) free_FIX_ComplexEventPriceTimeType;
  SwigClassComplexEventPriceTimeType.trackObjects = 0;
  
  SwigClassLastSwapPoints.klass = rb_define_class_under(mQuickfix, "LastSwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastSwapPoints, (void *) &SwigClassLastSwapPoints);
  rb_define_alloc_func(SwigClassLastSwapPoints.klass, _wrap_LastSwapPoints_allocate);
  rb_define_method(SwigClassLastSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_LastSwapPoints), -1);
  SwigClassLastSwapPoints.mark = 0;
  SwigClassLastSwapPoints.destroy = (void (*)(void *)) free_FIX_LastSwapPoints;
  SwigClassLastSwapPoints.trackObjects = 0;
  
  SwigClassUnderlyingFXRateCalc.klass = rb_define_class_under(mQuickfix, "UnderlyingFXRateCalc", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFXRateCalc, (void *) &SwigClassUnderlyingFXRateCalc);
  rb_define_alloc_func(SwigClassUnderlyingFXRateCalc.klass, _wrap_UnderlyingFXRateCalc_allocate);
  rb_define_method(SwigClassUnderlyingFXRateCalc.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFXRateCalc), -1);
  SwigClassUnderlyingFXRateCalc.mark = 0;
  SwigClassUnderlyingFXRateCalc.destroy = (void (*)(void *)) free_FIX_UnderlyingFXRateCalc;
  SwigClassUnderlyingFXRateCalc.trackObjects = 0;
  
  SwigClassListStatusText.klass = rb_define_class_under(mQuickfix, "ListStatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListStatusText, (void *) &SwigClassListStatusText);
  rb_define_alloc_func(SwigClassListStatusText.klass, _wrap_ListStatusText_allocate);
  rb_define_method(SwigClassListStatusText.klass, "initialize", VALUEFUNC(_wrap_new_ListStatusText), -1);
  SwigClassListStatusText.mark = 0;
  SwigClassListStatusText.destroy = (void (*)(void *)) free_FIX_ListStatusText;
  SwigClassListStatusText.trackObjects = 0;
  
  SwigClassOddLot.klass = rb_define_class_under(mQuickfix, "OddLot", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OddLot, (void *) &SwigClassOddLot);
  rb_define_alloc_func(SwigClassOddLot.klass, _wrap_OddLot_allocate);
  rb_define_method(SwigClassOddLot.klass, "initialize", VALUEFUNC(_wrap_new_OddLot), -1);
  SwigClassOddLot.mark = 0;
  SwigClassOddLot.destroy = (void (*)(void *)) free_FIX_OddLot;
  SwigClassOddLot.trackObjects = 0;
  
  SwigClassBookingUnit.klass = rb_define_class_under(mQuickfix, "BookingUnit", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BookingUnit, (void *) &SwigClassBookingUnit);
  rb_define_alloc_func(SwigClassBookingUnit.klass, _wrap_BookingUnit_allocate);
  rb_define_method(SwigClassBookingUnit.klass, "initialize", VALUEFUNC(_wrap_new_BookingUnit), -1);
  SwigClassBookingUnit.mark = 0;
  SwigClassBookingUnit.destroy = (void (*)(void *)) free_FIX_BookingUnit;
  SwigClassBookingUnit.trackObjects = 0;
  
  SwigClassLegAllocAcctIDSource.klass = rb_define_class_under(mQuickfix, "LegAllocAcctIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocAcctIDSource, (void *) &SwigClassLegAllocAcctIDSource);
  rb_define_alloc_func(SwigClassLegAllocAcctIDSource.klass, _wrap_LegAllocAcctIDSource_allocate);
  rb_define_method(SwigClassLegAllocAcctIDSource.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocAcctIDSource), -1);
  SwigClassLegAllocAcctIDSource.mark = 0;
  SwigClassLegAllocAcctIDSource.destroy = (void (*)(void *)) free_FIX_LegAllocAcctIDSource;
  SwigClassLegAllocAcctIDSource.trackObjects = 0;
  
  SwigClassOnBehalfOfSendingTime.klass = rb_define_class_under(mQuickfix, "OnBehalfOfSendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfSendingTime, (void *) &SwigClassOnBehalfOfSendingTime);
  rb_define_alloc_func(SwigClassOnBehalfOfSendingTime.klass, _wrap_OnBehalfOfSendingTime_allocate);
  rb_define_method(SwigClassOnBehalfOfSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfSendingTime), -1);
  SwigClassOnBehalfOfSendingTime.mark = 0;
  SwigClassOnBehalfOfSendingTime.destroy = (void (*)(void *)) free_FIX_OnBehalfOfSendingTime;
  SwigClassOnBehalfOfSendingTime.trackObjects = 0;
  
  SwigClassAllocStatus.klass = rb_define_class_under(mQuickfix, "AllocStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocStatus, (void *) &SwigClassAllocStatus);
  rb_define_alloc_func(SwigClassAllocStatus.klass, _wrap_AllocStatus_allocate);
  rb_define_method(SwigClassAllocStatus.klass, "initialize", VALUEFUNC(_wrap_new_AllocStatus), -1);
  SwigClassAllocStatus.mark = 0;
  SwigClassAllocStatus.destroy = (void (*)(void *)) free_FIX_AllocStatus;
  SwigClassAllocStatus.trackObjects = 0;
  
  SwigClassReferencePage.klass = rb_define_class_under(mQuickfix, "ReferencePage", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReferencePage, (void *) &SwigClassReferencePage);
  rb_define_alloc_func(SwigClassReferencePage.klass, _wrap_ReferencePage_allocate);
  rb_define_method(SwigClassReferencePage.klass, "initialize", VALUEFUNC(_wrap_new_ReferencePage), -1);
  SwigClassReferencePage.mark = 0;
  SwigClassReferencePage.destroy = (void (*)(void *)) free_FIX_ReferencePage;
  SwigClassReferencePage.trackObjects = 0;
  
  SwigClassDerivativeExerciseStyle.klass = rb_define_class_under(mQuickfix, "DerivativeExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeExerciseStyle, (void *) &SwigClassDerivativeExerciseStyle);
  rb_define_alloc_func(SwigClassDerivativeExerciseStyle.klass, _wrap_DerivativeExerciseStyle_allocate);
  rb_define_method(SwigClassDerivativeExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeExerciseStyle), -1);
  SwigClassDerivativeExerciseStyle.mark = 0;
  SwigClassDerivativeExerciseStyle.destroy = (void (*)(void *)) free_FIX_DerivativeExerciseStyle;
  SwigClassDerivativeExerciseStyle.trackObjects = 0;
  
  SwigClassApplBegSeqNum.klass = rb_define_class_under(mQuickfix, "ApplBegSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplBegSeqNum, (void *) &SwigClassApplBegSeqNum);
  rb_define_alloc_func(SwigClassApplBegSeqNum.klass, _wrap_ApplBegSeqNum_allocate);
  rb_define_method(SwigClassApplBegSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplBegSeqNum), -1);
  SwigClassApplBegSeqNum.mark = 0;
  SwigClassApplBegSeqNum.destroy = (void (*)(void *)) free_FIX_ApplBegSeqNum;
  SwigClassApplBegSeqNum.trackObjects = 0;
  
  SwigClassCollRptID.klass = rb_define_class_under(mQuickfix, "CollRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollRptID, (void *) &SwigClassCollRptID);
  rb_define_alloc_func(SwigClassCollRptID.klass, _wrap_CollRptID_allocate);
  rb_define_method(SwigClassCollRptID.klass, "initialize", VALUEFUNC(_wrap_new_CollRptID), -1);
  SwigClassCollRptID.mark = 0;
  SwigClassCollRptID.destroy = (void (*)(void *)) free_FIX_CollRptID;
  SwigClassCollRptID.trackObjects = 0;
  
  SwigClassIncTaxInd.klass = rb_define_class_under(mQuickfix, "IncTaxInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncTaxInd, (void *) &SwigClassIncTaxInd);
  rb_define_alloc_func(SwigClassIncTaxInd.klass, _wrap_IncTaxInd_allocate);
  rb_define_method(SwigClassIncTaxInd.klass, "initialize", VALUEFUNC(_wrap_new_IncTaxInd), -1);
  SwigClassIncTaxInd.mark = 0;
  SwigClassIncTaxInd.destroy = (void (*)(void *)) free_FIX_IncTaxInd;
  SwigClassIncTaxInd.trackObjects = 0;
  
  SwigClassNoBidDescriptors.klass = rb_define_class_under(mQuickfix, "NoBidDescriptors", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoBidDescriptors, (void *) &SwigClassNoBidDescriptors);
  rb_define_alloc_func(SwigClassNoBidDescriptors.klass, _wrap_NoBidDescriptors_allocate);
  rb_define_method(SwigClassNoBidDescriptors.klass, "initialize", VALUEFUNC(_wrap_new_NoBidDescriptors), -1);
  SwigClassNoBidDescriptors.mark = 0;
  SwigClassNoBidDescriptors.destroy = (void (*)(void *)) free_FIX_NoBidDescriptors;
  SwigClassNoBidDescriptors.trackObjects = 0;
  
  SwigClassLegCouponPaymentDate.klass = rb_define_class_under(mQuickfix, "LegCouponPaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCouponPaymentDate, (void *) &SwigClassLegCouponPaymentDate);
  rb_define_alloc_func(SwigClassLegCouponPaymentDate.klass, _wrap_LegCouponPaymentDate_allocate);
  rb_define_method(SwigClassLegCouponPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_LegCouponPaymentDate), -1);
  SwigClassLegCouponPaymentDate.mark = 0;
  SwigClassLegCouponPaymentDate.destroy = (void (*)(void *)) free_FIX_LegCouponPaymentDate;
  SwigClassLegCouponPaymentDate.trackObjects = 0;
  
  SwigClassNoUnderlyingLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoUnderlyingLegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID, (void *) &SwigClassNoUnderlyingLegSecurityAltID);
  rb_define_alloc_func(SwigClassNoUnderlyingLegSecurityAltID.klass, _wrap_NoUnderlyingLegSecurityAltID_allocate);
  rb_define_method(SwigClassNoUnderlyingLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingLegSecurityAltID), -1);
  SwigClassNoUnderlyingLegSecurityAltID.mark = 0;
  SwigClassNoUnderlyingLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoUnderlyingLegSecurityAltID;
  SwigClassNoUnderlyingLegSecurityAltID.trackObjects = 0;
  
  SwigClassReversalIndicator.klass = rb_define_class_under(mQuickfix, "ReversalIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReversalIndicator, (void *) &SwigClassReversalIndicator);
  rb_define_alloc_func(SwigClassReversalIndicator.klass, _wrap_ReversalIndicator_allocate);
  rb_define_method(SwigClassReversalIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ReversalIndicator), -1);
  SwigClassReversalIndicator.mark = 0;
  SwigClassReversalIndicator.destroy = (void (*)(void *)) free_FIX_ReversalIndicator;
  SwigClassReversalIndicator.trackObjects = 0;
  
  SwigClassCheckSum.klass = rb_define_class_under(mQuickfix, "CheckSum", ((swig_class *) SWIGTYPE_p_FIX__CheckSumField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CheckSum, (void *) &SwigClassCheckSum);
  rb_define_alloc_func(SwigClassCheckSum.klass, _wrap_CheckSum_allocate);
  rb_define_method(SwigClassCheckSum.klass, "initialize", VALUEFUNC(_wrap_new_CheckSum), -1);
  SwigClassCheckSum.mark = 0;
  SwigClassCheckSum.destroy = (void (*)(void *)) free_FIX_CheckSum;
  SwigClassCheckSum.trackObjects = 0;
  
  SwigClassTargetSubID.klass = rb_define_class_under(mQuickfix, "TargetSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetSubID, (void *) &SwigClassTargetSubID);
  rb_define_alloc_func(SwigClassTargetSubID.klass, _wrap_TargetSubID_allocate);
  rb_define_method(SwigClassTargetSubID.klass, "initialize", VALUEFUNC(_wrap_new_TargetSubID), -1);
  SwigClassTargetSubID.mark = 0;
  SwigClassTargetSubID.destroy = (void (*)(void *)) free_FIX_TargetSubID;
  SwigClassTargetSubID.trackObjects = 0;
  
  SwigClassPosReqStatus.klass = rb_define_class_under(mQuickfix, "PosReqStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqStatus, (void *) &SwigClassPosReqStatus);
  rb_define_alloc_func(SwigClassPosReqStatus.klass, _wrap_PosReqStatus_allocate);
  rb_define_method(SwigClassPosReqStatus.klass, "initialize", VALUEFUNC(_wrap_new_PosReqStatus), -1);
  SwigClassPosReqStatus.mark = 0;
  SwigClassPosReqStatus.destroy = (void (*)(void *)) free_FIX_PosReqStatus;
  SwigClassPosReqStatus.trackObjects = 0;
  
  SwigClassPriorityIndicator.klass = rb_define_class_under(mQuickfix, "PriorityIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriorityIndicator, (void *) &SwigClassPriorityIndicator);
  rb_define_alloc_func(SwigClassPriorityIndicator.klass, _wrap_PriorityIndicator_allocate);
  rb_define_method(SwigClassPriorityIndicator.klass, "initialize", VALUEFUNC(_wrap_new_PriorityIndicator), -1);
  SwigClassPriorityIndicator.mark = 0;
  SwigClassPriorityIndicator.destroy = (void (*)(void *)) free_FIX_PriorityIndicator;
  SwigClassPriorityIndicator.trackObjects = 0;
  
  SwigClassUnderlyingLegCFICode.klass = rb_define_class_under(mQuickfix, "UnderlyingLegCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegCFICode, (void *) &SwigClassUnderlyingLegCFICode);
  rb_define_alloc_func(SwigClassUnderlyingLegCFICode.klass, _wrap_UnderlyingLegCFICode_allocate);
  rb_define_method(SwigClassUnderlyingLegCFICode.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegCFICode), -1);
  SwigClassUnderlyingLegCFICode.mark = 0;
  SwigClassUnderlyingLegCFICode.destroy = (void (*)(void *)) free_FIX_UnderlyingLegCFICode;
  SwigClassUnderlyingLegCFICode.trackObjects = 0;
  
  SwigClassDerivativeTimeUnit.klass = rb_define_class_under(mQuickfix, "DerivativeTimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeTimeUnit, (void *) &SwigClassDerivativeTimeUnit);
  rb_define_alloc_func(SwigClassDerivativeTimeUnit.klass, _wrap_DerivativeTimeUnit_allocate);
  rb_define_method(SwigClassDerivativeTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeTimeUnit), -1);
  SwigClassDerivativeTimeUnit.mark = 0;
  SwigClassDerivativeTimeUnit.destroy = (void (*)(void *)) free_FIX_DerivativeTimeUnit;
  SwigClassDerivativeTimeUnit.trackObjects = 0;
  
  SwigClassNoNested3PartyIDs.klass = rb_define_class_under(mQuickfix, "NoNested3PartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested3PartyIDs, (void *) &SwigClassNoNested3PartyIDs);
  rb_define_alloc_func(SwigClassNoNested3PartyIDs.klass, _wrap_NoNested3PartyIDs_allocate);
  rb_define_method(SwigClassNoNested3PartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested3PartyIDs), -1);
  SwigClassNoNested3PartyIDs.mark = 0;
  SwigClassNoNested3PartyIDs.destroy = (void (*)(void *)) free_FIX_NoNested3PartyIDs;
  SwigClassNoNested3PartyIDs.trackObjects = 0;
  
  SwigClassLiquidityPctHigh.klass = rb_define_class_under(mQuickfix, "LiquidityPctHigh", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityPctHigh, (void *) &SwigClassLiquidityPctHigh);
  rb_define_alloc_func(SwigClassLiquidityPctHigh.klass, _wrap_LiquidityPctHigh_allocate);
  rb_define_method(SwigClassLiquidityPctHigh.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityPctHigh), -1);
  SwigClassLiquidityPctHigh.mark = 0;
  SwigClassLiquidityPctHigh.destroy = (void (*)(void *)) free_FIX_LiquidityPctHigh;
  SwigClassLiquidityPctHigh.trackObjects = 0;
  
  SwigClassMoneyLaunderingStatus.klass = rb_define_class_under(mQuickfix, "MoneyLaunderingStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MoneyLaunderingStatus, (void *) &SwigClassMoneyLaunderingStatus);
  rb_define_alloc_func(SwigClassMoneyLaunderingStatus.klass, _wrap_MoneyLaunderingStatus_allocate);
  rb_define_method(SwigClassMoneyLaunderingStatus.klass, "initialize", VALUEFUNC(_wrap_new_MoneyLaunderingStatus), -1);
  SwigClassMoneyLaunderingStatus.mark = 0;
  SwigClassMoneyLaunderingStatus.destroy = (void (*)(void *)) free_FIX_MoneyLaunderingStatus;
  SwigClassMoneyLaunderingStatus.trackObjects = 0;
  
  SwigClassNested4PartySubID.klass = rb_define_class_under(mQuickfix, "Nested4PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartySubID, (void *) &SwigClassNested4PartySubID);
  rb_define_alloc_func(SwigClassNested4PartySubID.klass, _wrap_Nested4PartySubID_allocate);
  rb_define_method(SwigClassNested4PartySubID.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartySubID), -1);
  SwigClassNested4PartySubID.mark = 0;
  SwigClassNested4PartySubID.destroy = (void (*)(void *)) free_FIX_Nested4PartySubID;
  SwigClassNested4PartySubID.trackObjects = 0;
  
  SwigClassDerivativeSecurityExchange.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityExchange, (void *) &SwigClassDerivativeSecurityExchange);
  rb_define_alloc_func(SwigClassDerivativeSecurityExchange.klass, _wrap_DerivativeSecurityExchange_allocate);
  rb_define_method(SwigClassDerivativeSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityExchange), -1);
  SwigClassDerivativeSecurityExchange.mark = 0;
  SwigClassDerivativeSecurityExchange.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityExchange;
  SwigClassDerivativeSecurityExchange.trackObjects = 0;
  
  SwigClassLotType.klass = rb_define_class_under(mQuickfix, "LotType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LotType, (void *) &SwigClassLotType);
  rb_define_alloc_func(SwigClassLotType.klass, _wrap_LotType_allocate);
  rb_define_method(SwigClassLotType.klass, "initialize", VALUEFUNC(_wrap_new_LotType), -1);
  SwigClassLotType.mark = 0;
  SwigClassLotType.destroy = (void (*)(void *)) free_FIX_LotType;
  SwigClassLotType.trackObjects = 0;
  
  SwigClassContIntRptID.klass = rb_define_class_under(mQuickfix, "ContIntRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContIntRptID, (void *) &SwigClassContIntRptID);
  rb_define_alloc_func(SwigClassContIntRptID.klass, _wrap_ContIntRptID_allocate);
  rb_define_method(SwigClassContIntRptID.klass, "initialize", VALUEFUNC(_wrap_new_ContIntRptID), -1);
  SwigClassContIntRptID.mark = 0;
  SwigClassContIntRptID.destroy = (void (*)(void *)) free_FIX_ContIntRptID;
  SwigClassContIntRptID.trackObjects = 0;
  
  SwigClassQuoteCondition.klass = rb_define_class_under(mQuickfix, "QuoteCondition", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteCondition, (void *) &SwigClassQuoteCondition);
  rb_define_alloc_func(SwigClassQuoteCondition.klass, _wrap_QuoteCondition_allocate);
  rb_define_method(SwigClassQuoteCondition.klass, "initialize", VALUEFUNC(_wrap_new_QuoteCondition), -1);
  SwigClassQuoteCondition.mark = 0;
  SwigClassQuoteCondition.destroy = (void (*)(void *)) free_FIX_QuoteCondition;
  SwigClassQuoteCondition.trackObjects = 0;
  
  SwigClassComplexEventStartTime.klass = rb_define_class_under(mQuickfix, "ComplexEventStartTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventStartTime, (void *) &SwigClassComplexEventStartTime);
  rb_define_alloc_func(SwigClassComplexEventStartTime.klass, _wrap_ComplexEventStartTime_allocate);
  rb_define_method(SwigClassComplexEventStartTime.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventStartTime), -1);
  SwigClassComplexEventStartTime.mark = 0;
  SwigClassComplexEventStartTime.destroy = (void (*)(void *)) free_FIX_ComplexEventStartTime;
  SwigClassComplexEventStartTime.trackObjects = 0;
  
  SwigClassNoComplexEvents.klass = rb_define_class_under(mQuickfix, "NoComplexEvents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoComplexEvents, (void *) &SwigClassNoComplexEvents);
  rb_define_alloc_func(SwigClassNoComplexEvents.klass, _wrap_NoComplexEvents_allocate);
  rb_define_method(SwigClassNoComplexEvents.klass, "initialize", VALUEFUNC(_wrap_new_NoComplexEvents), -1);
  SwigClassNoComplexEvents.mark = 0;
  SwigClassNoComplexEvents.destroy = (void (*)(void *)) free_FIX_NoComplexEvents;
  SwigClassNoComplexEvents.trackObjects = 0;
  
  SwigClassDerivativeContractMultiplier.klass = rb_define_class_under(mQuickfix, "DerivativeContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeContractMultiplier, (void *) &SwigClassDerivativeContractMultiplier);
  rb_define_alloc_func(SwigClassDerivativeContractMultiplier.klass, _wrap_DerivativeContractMultiplier_allocate);
  rb_define_method(SwigClassDerivativeContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeContractMultiplier), -1);
  SwigClassDerivativeContractMultiplier.mark = 0;
  SwigClassDerivativeContractMultiplier.destroy = (void (*)(void *)) free_FIX_DerivativeContractMultiplier;
  SwigClassDerivativeContractMultiplier.trackObjects = 0;
  
  SwigClassDerivativeSecurityStatus.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityStatus, (void *) &SwigClassDerivativeSecurityStatus);
  rb_define_alloc_func(SwigClassDerivativeSecurityStatus.klass, _wrap_DerivativeSecurityStatus_allocate);
  rb_define_method(SwigClassDerivativeSecurityStatus.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityStatus), -1);
  SwigClassDerivativeSecurityStatus.mark = 0;
  SwigClassDerivativeSecurityStatus.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityStatus;
  SwigClassDerivativeSecurityStatus.trackObjects = 0;
  
  SwigClassDerivativeProductComplex.klass = rb_define_class_under(mQuickfix, "DerivativeProductComplex", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeProductComplex, (void *) &SwigClassDerivativeProductComplex);
  rb_define_alloc_func(SwigClassDerivativeProductComplex.klass, _wrap_DerivativeProductComplex_allocate);
  rb_define_method(SwigClassDerivativeProductComplex.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeProductComplex), -1);
  SwigClassDerivativeProductComplex.mark = 0;
  SwigClassDerivativeProductComplex.destroy = (void (*)(void *)) free_FIX_DerivativeProductComplex;
  SwigClassDerivativeProductComplex.trackObjects = 0;
  
  SwigClassTriggerSymbol.klass = rb_define_class_under(mQuickfix, "TriggerSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSymbol, (void *) &SwigClassTriggerSymbol);
  rb_define_alloc_func(SwigClassTriggerSymbol.klass, _wrap_TriggerSymbol_allocate);
  rb_define_method(SwigClassTriggerSymbol.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSymbol), -1);
  SwigClassTriggerSymbol.mark = 0;
  SwigClassTriggerSymbol.destroy = (void (*)(void *)) free_FIX_TriggerSymbol;
  SwigClassTriggerSymbol.trackObjects = 0;
  
  SwigClassUnderlyingLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "UnderlyingLocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue, (void *) &SwigClassUnderlyingLocaleOfIssue);
  rb_define_alloc_func(SwigClassUnderlyingLocaleOfIssue.klass, _wrap_UnderlyingLocaleOfIssue_allocate);
  rb_define_method(SwigClassUnderlyingLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLocaleOfIssue), -1);
  SwigClassUnderlyingLocaleOfIssue.mark = 0;
  SwigClassUnderlyingLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_UnderlyingLocaleOfIssue;
  SwigClassUnderlyingLocaleOfIssue.trackObjects = 0;
  
  SwigClassSendingTime.klass = rb_define_class_under(mQuickfix, "SendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SendingTime, (void *) &SwigClassSendingTime);
  rb_define_alloc_func(SwigClassSendingTime.klass, _wrap_SendingTime_allocate);
  rb_define_method(SwigClassSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_SendingTime), -1);
  SwigClassSendingTime.mark = 0;
  SwigClassSendingTime.destroy = (void (*)(void *)) free_FIX_SendingTime;
  SwigClassSendingTime.trackObjects = 0;
  
  SwigClassComplexEventStartDate.klass = rb_define_class_under(mQuickfix, "ComplexEventStartDate", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventStartDate, (void *) &SwigClassComplexEventStartDate);
  rb_define_alloc_func(SwigClassComplexEventStartDate.klass, _wrap_ComplexEventStartDate_allocate);
  rb_define_method(SwigClassComplexEventStartDate.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventStartDate), -1);
  SwigClassComplexEventStartDate.mark = 0;
  SwigClassComplexEventStartDate.destroy = (void (*)(void *)) free_FIX_ComplexEventStartDate;
  SwigClassComplexEventStartDate.trackObjects = 0;
  
  SwigClassUnderlyingRestructuringType.klass = rb_define_class_under(mQuickfix, "UnderlyingRestructuringType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRestructuringType, (void *) &SwigClassUnderlyingRestructuringType);
  rb_define_alloc_func(SwigClassUnderlyingRestructuringType.klass, _wrap_UnderlyingRestructuringType_allocate);
  rb_define_method(SwigClassUnderlyingRestructuringType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRestructuringType), -1);
  SwigClassUnderlyingRestructuringType.mark = 0;
  SwigClassUnderlyingRestructuringType.destroy = (void (*)(void *)) free_FIX_UnderlyingRestructuringType;
  SwigClassUnderlyingRestructuringType.trackObjects = 0;
  
  SwigClassLegUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "LegUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegUnitOfMeasureQty, (void *) &SwigClassLegUnitOfMeasureQty);
  rb_define_alloc_func(SwigClassLegUnitOfMeasureQty.klass, _wrap_LegUnitOfMeasureQty_allocate);
  rb_define_method(SwigClassLegUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_LegUnitOfMeasureQty), -1);
  SwigClassLegUnitOfMeasureQty.mark = 0;
  SwigClassLegUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_LegUnitOfMeasureQty;
  SwigClassLegUnitOfMeasureQty.trackObjects = 0;
  
  SwigClassNoTrdRegTimestamps.klass = rb_define_class_under(mQuickfix, "NoTrdRegTimestamps", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTrdRegTimestamps, (void *) &SwigClassNoTrdRegTimestamps);
  rb_define_alloc_func(SwigClassNoTrdRegTimestamps.klass, _wrap_NoTrdRegTimestamps_allocate);
  rb_define_method(SwigClassNoTrdRegTimestamps.klass, "initialize", VALUEFUNC(_wrap_new_NoTrdRegTimestamps), -1);
  SwigClassNoTrdRegTimestamps.mark = 0;
  SwigClassNoTrdRegTimestamps.destroy = (void (*)(void *)) free_FIX_NoTrdRegTimestamps;
  SwigClassNoTrdRegTimestamps.trackObjects = 0;
  
  SwigClassSendingDate.klass = rb_define_class_under(mQuickfix, "SendingDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SendingDate, (void *) &SwigClassSendingDate);
  rb_define_alloc_func(SwigClassSendingDate.klass, _wrap_SendingDate_allocate);
  rb_define_method(SwigClassSendingDate.klass, "initialize", VALUEFUNC(_wrap_new_SendingDate), -1);
  SwigClassSendingDate.mark = 0;
  SwigClassSendingDate.destroy = (void (*)(void *)) free_FIX_SendingDate;
  SwigClassSendingDate.trackObjects = 0;
  
  SwigClassTimeToExpiration.klass = rb_define_class_under(mQuickfix, "TimeToExpiration", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeToExpiration, (void *) &SwigClassTimeToExpiration);
  rb_define_alloc_func(SwigClassTimeToExpiration.klass, _wrap_TimeToExpiration_allocate);
  rb_define_method(SwigClassTimeToExpiration.klass, "initialize", VALUEFUNC(_wrap_new_TimeToExpiration), -1);
  SwigClassTimeToExpiration.mark = 0;
  SwigClassTimeToExpiration.destroy = (void (*)(void *)) free_FIX_TimeToExpiration;
  SwigClassTimeToExpiration.trackObjects = 0;
  
  SwigClassLegAllocQty.klass = rb_define_class_under(mQuickfix, "LegAllocQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocQty, (void *) &SwigClassLegAllocQty);
  rb_define_alloc_func(SwigClassLegAllocQty.klass, _wrap_LegAllocQty_allocate);
  rb_define_method(SwigClassLegAllocQty.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocQty), -1);
  SwigClassLegAllocQty.mark = 0;
  SwigClassLegAllocQty.destroy = (void (*)(void *)) free_FIX_LegAllocQty;
  SwigClassLegAllocQty.trackObjects = 0;
  
  SwigClassSettlLocation.klass = rb_define_class_under(mQuickfix, "SettlLocation", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlLocation, (void *) &SwigClassSettlLocation);
  rb_define_alloc_func(SwigClassSettlLocation.klass, _wrap_SettlLocation_allocate);
  rb_define_method(SwigClassSettlLocation.klass, "initialize", VALUEFUNC(_wrap_new_SettlLocation), -1);
  SwigClassSettlLocation.mark = 0;
  SwigClassSettlLocation.destroy = (void (*)(void *)) free_FIX_SettlLocation;
  SwigClassSettlLocation.trackObjects = 0;
  
  SwigClassUnderlyingExerciseStyle.klass = rb_define_class_under(mQuickfix, "UnderlyingExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingExerciseStyle, (void *) &SwigClassUnderlyingExerciseStyle);
  rb_define_alloc_func(SwigClassUnderlyingExerciseStyle.klass, _wrap_UnderlyingExerciseStyle_allocate);
  rb_define_method(SwigClassUnderlyingExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingExerciseStyle), -1);
  SwigClassUnderlyingExerciseStyle.mark = 0;
  SwigClassUnderlyingExerciseStyle.destroy = (void (*)(void *)) free_FIX_UnderlyingExerciseStyle;
  SwigClassUnderlyingExerciseStyle.trackObjects = 0;
  
  SwigClassCashSettlAgentContactName.klass = rb_define_class_under(mQuickfix, "CashSettlAgentContactName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentContactName, (void *) &SwigClassCashSettlAgentContactName);
  rb_define_alloc_func(SwigClassCashSettlAgentContactName.klass, _wrap_CashSettlAgentContactName_allocate);
  rb_define_method(SwigClassCashSettlAgentContactName.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentContactName), -1);
  SwigClassCashSettlAgentContactName.mark = 0;
  SwigClassCashSettlAgentContactName.destroy = (void (*)(void *)) free_FIX_CashSettlAgentContactName;
  SwigClassCashSettlAgentContactName.trackObjects = 0;
  
  SwigClassLegRepurchaseRate.klass = rb_define_class_under(mQuickfix, "LegRepurchaseRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRepurchaseRate, (void *) &SwigClassLegRepurchaseRate);
  rb_define_alloc_func(SwigClassLegRepurchaseRate.klass, _wrap_LegRepurchaseRate_allocate);
  rb_define_method(SwigClassLegRepurchaseRate.klass, "initialize", VALUEFUNC(_wrap_new_LegRepurchaseRate), -1);
  SwigClassLegRepurchaseRate.mark = 0;
  SwigClassLegRepurchaseRate.destroy = (void (*)(void *)) free_FIX_LegRepurchaseRate;
  SwigClassLegRepurchaseRate.trackObjects = 0;
  
  SwigClassApplResponseID.klass = rb_define_class_under(mQuickfix, "ApplResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResponseID, (void *) &SwigClassApplResponseID);
  rb_define_alloc_func(SwigClassApplResponseID.klass, _wrap_ApplResponseID_allocate);
  rb_define_method(SwigClassApplResponseID.klass, "initialize", VALUEFUNC(_wrap_new_ApplResponseID), -1);
  SwigClassApplResponseID.mark = 0;
  SwigClassApplResponseID.destroy = (void (*)(void *)) free_FIX_ApplResponseID;
  SwigClassApplResponseID.trackObjects = 0;
  
  SwigClassNoDerivativeInstrAttrib.klass = rb_define_class_under(mQuickfix, "NoDerivativeInstrAttrib", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeInstrAttrib, (void *) &SwigClassNoDerivativeInstrAttrib);
  rb_define_alloc_func(SwigClassNoDerivativeInstrAttrib.klass, _wrap_NoDerivativeInstrAttrib_allocate);
  rb_define_method(SwigClassNoDerivativeInstrAttrib.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeInstrAttrib), -1);
  SwigClassNoDerivativeInstrAttrib.mark = 0;
  SwigClassNoDerivativeInstrAttrib.destroy = (void (*)(void *)) free_FIX_NoDerivativeInstrAttrib;
  SwigClassNoDerivativeInstrAttrib.trackObjects = 0;
  
  SwigClassDerivativeStrikeMultiplier.klass = rb_define_class_under(mQuickfix, "DerivativeStrikeMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikeMultiplier, (void *) &SwigClassDerivativeStrikeMultiplier);
  rb_define_alloc_func(SwigClassDerivativeStrikeMultiplier.klass, _wrap_DerivativeStrikeMultiplier_allocate);
  rb_define_method(SwigClassDerivativeStrikeMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikeMultiplier), -1);
  SwigClassDerivativeStrikeMultiplier.mark = 0;
  SwigClassDerivativeStrikeMultiplier.destroy = (void (*)(void *)) free_FIX_DerivativeStrikeMultiplier;
  SwigClassDerivativeStrikeMultiplier.trackObjects = 0;
  
  SwigClassLegStrikeCurrency.klass = rb_define_class_under(mQuickfix, "LegStrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStrikeCurrency, (void *) &SwigClassLegStrikeCurrency);
  rb_define_alloc_func(SwigClassLegStrikeCurrency.klass, _wrap_LegStrikeCurrency_allocate);
  rb_define_method(SwigClassLegStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegStrikeCurrency), -1);
  SwigClassLegStrikeCurrency.mark = 0;
  SwigClassLegStrikeCurrency.destroy = (void (*)(void *)) free_FIX_LegStrikeCurrency;
  SwigClassLegStrikeCurrency.trackObjects = 0;
  
  SwigClassSecurityStatusReqID.klass = rb_define_class_under(mQuickfix, "SecurityStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityStatusReqID, (void *) &SwigClassSecurityStatusReqID);
  rb_define_alloc_func(SwigClassSecurityStatusReqID.klass, _wrap_SecurityStatusReqID_allocate);
  rb_define_method(SwigClassSecurityStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityStatusReqID), -1);
  SwigClassSecurityStatusReqID.mark = 0;
  SwigClassSecurityStatusReqID.destroy = (void (*)(void *)) free_FIX_SecurityStatusReqID;
  SwigClassSecurityStatusReqID.trackObjects = 0;
  
  SwigClassSecureDataLen.klass = rb_define_class_under(mQuickfix, "SecureDataLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecureDataLen, (void *) &SwigClassSecureDataLen);
  rb_define_alloc_func(SwigClassSecureDataLen.klass, _wrap_SecureDataLen_allocate);
  rb_define_method(SwigClassSecureDataLen.klass, "initialize", VALUEFUNC(_wrap_new_SecureDataLen), -1);
  SwigClassSecureDataLen.mark = 0;
  SwigClassSecureDataLen.destroy = (void (*)(void *)) free_FIX_SecureDataLen;
  SwigClassSecureDataLen.trackObjects = 0;
  
  SwigClassDiscretionScope.klass = rb_define_class_under(mQuickfix, "DiscretionScope", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionScope, (void *) &SwigClassDiscretionScope);
  rb_define_alloc_func(SwigClassDiscretionScope.klass, _wrap_DiscretionScope_allocate);
  rb_define_method(SwigClassDiscretionScope.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionScope), -1);
  SwigClassDiscretionScope.mark = 0;
  SwigClassDiscretionScope.destroy = (void (*)(void *)) free_FIX_DiscretionScope;
  SwigClassDiscretionScope.trackObjects = 0;
  
  SwigClassOwnerType.klass = rb_define_class_under(mQuickfix, "OwnerType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OwnerType, (void *) &SwigClassOwnerType);
  rb_define_alloc_func(SwigClassOwnerType.klass, _wrap_OwnerType_allocate);
  rb_define_method(SwigClassOwnerType.klass, "initialize", VALUEFUNC(_wrap_new_OwnerType), -1);
  SwigClassOwnerType.mark = 0;
  SwigClassOwnerType.destroy = (void (*)(void *)) free_FIX_OwnerType;
  SwigClassOwnerType.trackObjects = 0;
  
  SwigClassShares.klass = rb_define_class_under(mQuickfix, "Shares", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Shares, (void *) &SwigClassShares);
  rb_define_alloc_func(SwigClassShares.klass, _wrap_Shares_allocate);
  rb_define_method(SwigClassShares.klass, "initialize", VALUEFUNC(_wrap_new_Shares), -1);
  SwigClassShares.mark = 0;
  SwigClassShares.destroy = (void (*)(void *)) free_FIX_Shares;
  SwigClassShares.trackObjects = 0;
  
  SwigClassYield.klass = rb_define_class_under(mQuickfix, "Yield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Yield, (void *) &SwigClassYield);
  rb_define_alloc_func(SwigClassYield.klass, _wrap_Yield_allocate);
  rb_define_method(SwigClassYield.klass, "initialize", VALUEFUNC(_wrap_new_Yield), -1);
  SwigClassYield.mark = 0;
  SwigClassYield.destroy = (void (*)(void *)) free_FIX_Yield;
  SwigClassYield.trackObjects = 0;
  
  SwigClassQuoteRespID.klass = rb_define_class_under(mQuickfix, "QuoteRespID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRespID, (void *) &SwigClassQuoteRespID);
  rb_define_alloc_func(SwigClassQuoteRespID.klass, _wrap_QuoteRespID_allocate);
  rb_define_method(SwigClassQuoteRespID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRespID), -1);
  SwigClassQuoteRespID.mark = 0;
  SwigClassQuoteRespID.destroy = (void (*)(void *)) free_FIX_QuoteRespID;
  SwigClassQuoteRespID.trackObjects = 0;
  
  SwigClassNested3PartySubID.klass = rb_define_class_under(mQuickfix, "Nested3PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartySubID, (void *) &SwigClassNested3PartySubID);
  rb_define_alloc_func(SwigClassNested3PartySubID.klass, _wrap_Nested3PartySubID_allocate);
  rb_define_method(SwigClassNested3PartySubID.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartySubID), -1);
  SwigClassNested3PartySubID.mark = 0;
  SwigClassNested3PartySubID.destroy = (void (*)(void *)) free_FIX_Nested3PartySubID;
  SwigClassNested3PartySubID.trackObjects = 0;
  
  SwigClassApplQueueResolution.klass = rb_define_class_under(mQuickfix, "ApplQueueResolution", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueResolution, (void *) &SwigClassApplQueueResolution);
  rb_define_alloc_func(SwigClassApplQueueResolution.klass, _wrap_ApplQueueResolution_allocate);
  rb_define_method(SwigClassApplQueueResolution.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueResolution), -1);
  SwigClassApplQueueResolution.mark = 0;
  SwigClassApplQueueResolution.destroy = (void (*)(void *)) free_FIX_ApplQueueResolution;
  SwigClassApplQueueResolution.trackObjects = 0;
  
  SwigClassTrdRegTimestampOrigin.klass = rb_define_class_under(mQuickfix, "TrdRegTimestampOrigin", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRegTimestampOrigin, (void *) &SwigClassTrdRegTimestampOrigin);
  rb_define_alloc_func(SwigClassTrdRegTimestampOrigin.klass, _wrap_TrdRegTimestampOrigin_allocate);
  rb_define_method(SwigClassTrdRegTimestampOrigin.klass, "initialize", VALUEFUNC(_wrap_new_TrdRegTimestampOrigin), -1);
  SwigClassTrdRegTimestampOrigin.mark = 0;
  SwigClassTrdRegTimestampOrigin.destroy = (void (*)(void *)) free_FIX_TrdRegTimestampOrigin;
  SwigClassTrdRegTimestampOrigin.trackObjects = 0;
  
  SwigClassNested2PartyRole.klass = rb_define_class_under(mQuickfix, "Nested2PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartyRole, (void *) &SwigClassNested2PartyRole);
  rb_define_alloc_func(SwigClassNested2PartyRole.klass, _wrap_Nested2PartyRole_allocate);
  rb_define_method(SwigClassNested2PartyRole.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartyRole), -1);
  SwigClassNested2PartyRole.mark = 0;
  SwigClassNested2PartyRole.destroy = (void (*)(void *)) free_FIX_Nested2PartyRole;
  SwigClassNested2PartyRole.trackObjects = 0;
  
  SwigClassNested2PartyID.klass = rb_define_class_under(mQuickfix, "Nested2PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartyID, (void *) &SwigClassNested2PartyID);
  rb_define_alloc_func(SwigClassNested2PartyID.klass, _wrap_Nested2PartyID_allocate);
  rb_define_method(SwigClassNested2PartyID.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartyID), -1);
  SwigClassNested2PartyID.mark = 0;
  SwigClassNested2PartyID.destroy = (void (*)(void *)) free_FIX_Nested2PartyID;
  SwigClassNested2PartyID.trackObjects = 0;
  
  SwigClassBidSize.klass = rb_define_class_under(mQuickfix, "BidSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidSize, (void *) &SwigClassBidSize);
  rb_define_alloc_func(SwigClassBidSize.klass, _wrap_BidSize_allocate);
  rb_define_method(SwigClassBidSize.klass, "initialize", VALUEFUNC(_wrap_new_BidSize), -1);
  SwigClassBidSize.mark = 0;
  SwigClassBidSize.destroy = (void (*)(void *)) free_FIX_BidSize;
  SwigClassBidSize.trackObjects = 0;
  
  SwigClassLegSymbolSfx.klass = rb_define_class_under(mQuickfix, "LegSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSymbolSfx, (void *) &SwigClassLegSymbolSfx);
  rb_define_alloc_func(SwigClassLegSymbolSfx.klass, _wrap_LegSymbolSfx_allocate);
  rb_define_method(SwigClassLegSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_LegSymbolSfx), -1);
  SwigClassLegSymbolSfx.mark = 0;
  SwigClassLegSymbolSfx.destroy = (void (*)(void *)) free_FIX_LegSymbolSfx;
  SwigClassLegSymbolSfx.trackObjects = 0;
  
  SwigClassQuoteResponseLevel.klass = rb_define_class_under(mQuickfix, "QuoteResponseLevel", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteResponseLevel, (void *) &SwigClassQuoteResponseLevel);
  rb_define_alloc_func(SwigClassQuoteResponseLevel.klass, _wrap_QuoteResponseLevel_allocate);
  rb_define_method(SwigClassQuoteResponseLevel.klass, "initialize", VALUEFUNC(_wrap_new_QuoteResponseLevel), -1);
  SwigClassQuoteResponseLevel.mark = 0;
  SwigClassQuoteResponseLevel.destroy = (void (*)(void *)) free_FIX_QuoteResponseLevel;
  SwigClassQuoteResponseLevel.trackObjects = 0;
  
  SwigClassBodyLength.klass = rb_define_class_under(mQuickfix, "BodyLength", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BodyLength, (void *) &SwigClassBodyLength);
  rb_define_alloc_func(SwigClassBodyLength.klass, _wrap_BodyLength_allocate);
  rb_define_method(SwigClassBodyLength.klass, "initialize", VALUEFUNC(_wrap_new_BodyLength), -1);
  SwigClassBodyLength.mark = 0;
  SwigClassBodyLength.destroy = (void (*)(void *)) free_FIX_BodyLength;
  SwigClassBodyLength.trackObjects = 0;
  
  SwigClassListExecInst.klass = rb_define_class_under(mQuickfix, "ListExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListExecInst, (void *) &SwigClassListExecInst);
  rb_define_alloc_func(SwigClassListExecInst.klass, _wrap_ListExecInst_allocate);
  rb_define_method(SwigClassListExecInst.klass, "initialize", VALUEFUNC(_wrap_new_ListExecInst), -1);
  SwigClassListExecInst.mark = 0;
  SwigClassListExecInst.destroy = (void (*)(void *)) free_FIX_ListExecInst;
  SwigClassListExecInst.trackObjects = 0;
  
  SwigClassExecAckStatus.klass = rb_define_class_under(mQuickfix, "ExecAckStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecAckStatus, (void *) &SwigClassExecAckStatus);
  rb_define_alloc_func(SwigClassExecAckStatus.klass, _wrap_ExecAckStatus_allocate);
  rb_define_method(SwigClassExecAckStatus.klass, "initialize", VALUEFUNC(_wrap_new_ExecAckStatus), -1);
  SwigClassExecAckStatus.mark = 0;
  SwigClassExecAckStatus.destroy = (void (*)(void *)) free_FIX_ExecAckStatus;
  SwigClassExecAckStatus.trackObjects = 0;
  
  SwigClassSettlDate2.klass = rb_define_class_under(mQuickfix, "SettlDate2", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDate2, (void *) &SwigClassSettlDate2);
  rb_define_alloc_func(SwigClassSettlDate2.klass, _wrap_SettlDate2_allocate);
  rb_define_method(SwigClassSettlDate2.klass, "initialize", VALUEFUNC(_wrap_new_SettlDate2), -1);
  SwigClassSettlDate2.mark = 0;
  SwigClassSettlDate2.destroy = (void (*)(void *)) free_FIX_SettlDate2;
  SwigClassSettlDate2.trackObjects = 0;
  
  SwigClassNetGrossInd.klass = rb_define_class_under(mQuickfix, "NetGrossInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetGrossInd, (void *) &SwigClassNetGrossInd);
  rb_define_alloc_func(SwigClassNetGrossInd.klass, _wrap_NetGrossInd_allocate);
  rb_define_method(SwigClassNetGrossInd.klass, "initialize", VALUEFUNC(_wrap_new_NetGrossInd), -1);
  SwigClassNetGrossInd.mark = 0;
  SwigClassNetGrossInd.destroy = (void (*)(void *)) free_FIX_NetGrossInd;
  SwigClassNetGrossInd.trackObjects = 0;
  
  SwigClassUnderlyingSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource, (void *) &SwigClassUnderlyingSecurityAltIDSource);
  rb_define_alloc_func(SwigClassUnderlyingSecurityAltIDSource.klass, _wrap_UnderlyingSecurityAltIDSource_allocate);
  rb_define_method(SwigClassUnderlyingSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityAltIDSource), -1);
  SwigClassUnderlyingSecurityAltIDSource.mark = 0;
  SwigClassUnderlyingSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityAltIDSource;
  SwigClassUnderlyingSecurityAltIDSource.trackObjects = 0;
  
  SwigClassTestReqID.klass = rb_define_class_under(mQuickfix, "TestReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TestReqID, (void *) &SwigClassTestReqID);
  rb_define_alloc_func(SwigClassTestReqID.klass, _wrap_TestReqID_allocate);
  rb_define_method(SwigClassTestReqID.klass, "initialize", VALUEFUNC(_wrap_new_TestReqID), -1);
  SwigClassTestReqID.mark = 0;
  SwigClassTestReqID.destroy = (void (*)(void *)) free_FIX_TestReqID;
  SwigClassTestReqID.trackObjects = 0;
  
  SwigClassCxlType.klass = rb_define_class_under(mQuickfix, "CxlType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlType, (void *) &SwigClassCxlType);
  rb_define_alloc_func(SwigClassCxlType.klass, _wrap_CxlType_allocate);
  rb_define_method(SwigClassCxlType.klass, "initialize", VALUEFUNC(_wrap_new_CxlType), -1);
  SwigClassCxlType.mark = 0;
  SwigClassCxlType.destroy = (void (*)(void *)) free_FIX_CxlType;
  SwigClassCxlType.trackObjects = 0;
  
  SwigClassUnderlyingCreditRating.klass = rb_define_class_under(mQuickfix, "UnderlyingCreditRating", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCreditRating, (void *) &SwigClassUnderlyingCreditRating);
  rb_define_alloc_func(SwigClassUnderlyingCreditRating.klass, _wrap_UnderlyingCreditRating_allocate);
  rb_define_method(SwigClassUnderlyingCreditRating.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCreditRating), -1);
  SwigClassUnderlyingCreditRating.mark = 0;
  SwigClassUnderlyingCreditRating.destroy = (void (*)(void *)) free_FIX_UnderlyingCreditRating;
  SwigClassUnderlyingCreditRating.trackObjects = 0;
  
  SwigClassAvgPxPrecision.klass = rb_define_class_under(mQuickfix, "AvgPxPrecision", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPxPrecision, (void *) &SwigClassAvgPxPrecision);
  rb_define_alloc_func(SwigClassAvgPxPrecision.klass, _wrap_AvgPxPrecision_allocate);
  rb_define_method(SwigClassAvgPxPrecision.klass, "initialize", VALUEFUNC(_wrap_new_AvgPxPrecision), -1);
  SwigClassAvgPxPrecision.mark = 0;
  SwigClassAvgPxPrecision.destroy = (void (*)(void *)) free_FIX_AvgPxPrecision;
  SwigClassAvgPxPrecision.trackObjects = 0;
  
  SwigClassBenchmarkPriceType.klass = rb_define_class_under(mQuickfix, "BenchmarkPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkPriceType, (void *) &SwigClassBenchmarkPriceType);
  rb_define_alloc_func(SwigClassBenchmarkPriceType.klass, _wrap_BenchmarkPriceType_allocate);
  rb_define_method(SwigClassBenchmarkPriceType.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkPriceType), -1);
  SwigClassBenchmarkPriceType.mark = 0;
  SwigClassBenchmarkPriceType.destroy = (void (*)(void *)) free_FIX_BenchmarkPriceType;
  SwigClassBenchmarkPriceType.trackObjects = 0;
  
  SwigClassDeskTypeSource.klass = rb_define_class_under(mQuickfix, "DeskTypeSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskTypeSource, (void *) &SwigClassDeskTypeSource);
  rb_define_alloc_func(SwigClassDeskTypeSource.klass, _wrap_DeskTypeSource_allocate);
  rb_define_method(SwigClassDeskTypeSource.klass, "initialize", VALUEFUNC(_wrap_new_DeskTypeSource), -1);
  SwigClassDeskTypeSource.mark = 0;
  SwigClassDeskTypeSource.destroy = (void (*)(void *)) free_FIX_DeskTypeSource;
  SwigClassDeskTypeSource.trackObjects = 0;
  
  SwigClassDiscretionRoundDirection.klass = rb_define_class_under(mQuickfix, "DiscretionRoundDirection", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionRoundDirection, (void *) &SwigClassDiscretionRoundDirection);
  rb_define_alloc_func(SwigClassDiscretionRoundDirection.klass, _wrap_DiscretionRoundDirection_allocate);
  rb_define_method(SwigClassDiscretionRoundDirection.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionRoundDirection), -1);
  SwigClassDiscretionRoundDirection.mark = 0;
  SwigClassDiscretionRoundDirection.destroy = (void (*)(void *)) free_FIX_DiscretionRoundDirection;
  SwigClassDiscretionRoundDirection.trackObjects = 0;
  
  SwigClassOrigSecondaryTradeID.klass = rb_define_class_under(mQuickfix, "OrigSecondaryTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigSecondaryTradeID, (void *) &SwigClassOrigSecondaryTradeID);
  rb_define_alloc_func(SwigClassOrigSecondaryTradeID.klass, _wrap_OrigSecondaryTradeID_allocate);
  rb_define_method(SwigClassOrigSecondaryTradeID.klass, "initialize", VALUEFUNC(_wrap_new_OrigSecondaryTradeID), -1);
  SwigClassOrigSecondaryTradeID.mark = 0;
  SwigClassOrigSecondaryTradeID.destroy = (void (*)(void *)) free_FIX_OrigSecondaryTradeID;
  SwigClassOrigSecondaryTradeID.trackObjects = 0;
  
  SwigClassReceivedDeptID.klass = rb_define_class_under(mQuickfix, "ReceivedDeptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReceivedDeptID, (void *) &SwigClassReceivedDeptID);
  rb_define_alloc_func(SwigClassReceivedDeptID.klass, _wrap_ReceivedDeptID_allocate);
  rb_define_method(SwigClassReceivedDeptID.klass, "initialize", VALUEFUNC(_wrap_new_ReceivedDeptID), -1);
  SwigClassReceivedDeptID.mark = 0;
  SwigClassReceivedDeptID.destroy = (void (*)(void *)) free_FIX_ReceivedDeptID;
  SwigClassReceivedDeptID.trackObjects = 0;
  
  SwigClassMaturityNetMoney.klass = rb_define_class_under(mQuickfix, "MaturityNetMoney", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityNetMoney, (void *) &SwigClassMaturityNetMoney);
  rb_define_alloc_func(SwigClassMaturityNetMoney.klass, _wrap_MaturityNetMoney_allocate);
  rb_define_method(SwigClassMaturityNetMoney.klass, "initialize", VALUEFUNC(_wrap_new_MaturityNetMoney), -1);
  SwigClassMaturityNetMoney.mark = 0;
  SwigClassMaturityNetMoney.destroy = (void (*)(void *)) free_FIX_MaturityNetMoney;
  SwigClassMaturityNetMoney.trackObjects = 0;
  
  SwigClassBidDescriptorType.klass = rb_define_class_under(mQuickfix, "BidDescriptorType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidDescriptorType, (void *) &SwigClassBidDescriptorType);
  rb_define_alloc_func(SwigClassBidDescriptorType.klass, _wrap_BidDescriptorType_allocate);
  rb_define_method(SwigClassBidDescriptorType.klass, "initialize", VALUEFUNC(_wrap_new_BidDescriptorType), -1);
  SwigClassBidDescriptorType.mark = 0;
  SwigClassBidDescriptorType.destroy = (void (*)(void *)) free_FIX_BidDescriptorType;
  SwigClassBidDescriptorType.trackObjects = 0;
  
  SwigClassDerivativeInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID, (void *) &SwigClassDerivativeInstrumentPartySubID);
  rb_define_alloc_func(SwigClassDerivativeInstrumentPartySubID.klass, _wrap_DerivativeInstrumentPartySubID_allocate);
  rb_define_method(SwigClassDerivativeInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartySubID), -1);
  SwigClassDerivativeInstrumentPartySubID.mark = 0;
  SwigClassDerivativeInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartySubID;
  SwigClassDerivativeInstrumentPartySubID.trackObjects = 0;
  
  SwigClassNetworkStatusResponseType.klass = rb_define_class_under(mQuickfix, "NetworkStatusResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkStatusResponseType, (void *) &SwigClassNetworkStatusResponseType);
  rb_define_alloc_func(SwigClassNetworkStatusResponseType.klass, _wrap_NetworkStatusResponseType_allocate);
  rb_define_method(SwigClassNetworkStatusResponseType.klass, "initialize", VALUEFUNC(_wrap_new_NetworkStatusResponseType), -1);
  SwigClassNetworkStatusResponseType.mark = 0;
  SwigClassNetworkStatusResponseType.destroy = (void (*)(void *)) free_FIX_NetworkStatusResponseType;
  SwigClassNetworkStatusResponseType.trackObjects = 0;
  
  SwigClassDateOfBirth.klass = rb_define_class_under(mQuickfix, "DateOfBirth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DateOfBirth, (void *) &SwigClassDateOfBirth);
  rb_define_alloc_func(SwigClassDateOfBirth.klass, _wrap_DateOfBirth_allocate);
  rb_define_method(SwigClassDateOfBirth.klass, "initialize", VALUEFUNC(_wrap_new_DateOfBirth), -1);
  SwigClassDateOfBirth.mark = 0;
  SwigClassDateOfBirth.destroy = (void (*)(void *)) free_FIX_DateOfBirth;
  SwigClassDateOfBirth.trackObjects = 0;
  
  SwigClassStartStrikePxRange.klass = rb_define_class_under(mQuickfix, "StartStrikePxRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartStrikePxRange, (void *) &SwigClassStartStrikePxRange);
  rb_define_alloc_func(SwigClassStartStrikePxRange.klass, _wrap_StartStrikePxRange_allocate);
  rb_define_method(SwigClassStartStrikePxRange.klass, "initialize", VALUEFUNC(_wrap_new_StartStrikePxRange), -1);
  SwigClassStartStrikePxRange.mark = 0;
  SwigClassStartStrikePxRange.destroy = (void (*)(void *)) free_FIX_StartStrikePxRange;
  SwigClassStartStrikePxRange.trackObjects = 0;
  
  SwigClassUndlyInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartySubID, (void *) &SwigClassUndlyInstrumentPartySubID);
  rb_define_alloc_func(SwigClassUndlyInstrumentPartySubID.klass, _wrap_UndlyInstrumentPartySubID_allocate);
  rb_define_method(SwigClassUndlyInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartySubID), -1);
  SwigClassUndlyInstrumentPartySubID.mark = 0;
  SwigClassUndlyInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartySubID;
  SwigClassUndlyInstrumentPartySubID.trackObjects = 0;
  
  SwigClassSecondaryTradeReportRefID.klass = rb_define_class_under(mQuickfix, "SecondaryTradeReportRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradeReportRefID, (void *) &SwigClassSecondaryTradeReportRefID);
  rb_define_alloc_func(SwigClassSecondaryTradeReportRefID.klass, _wrap_SecondaryTradeReportRefID_allocate);
  rb_define_method(SwigClassSecondaryTradeReportRefID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradeReportRefID), -1);
  SwigClassSecondaryTradeReportRefID.mark = 0;
  SwigClassSecondaryTradeReportRefID.destroy = (void (*)(void *)) free_FIX_SecondaryTradeReportRefID;
  SwigClassSecondaryTradeReportRefID.trackObjects = 0;
  
  SwigClassUnderlyingCPRegType.klass = rb_define_class_under(mQuickfix, "UnderlyingCPRegType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCPRegType, (void *) &SwigClassUnderlyingCPRegType);
  rb_define_alloc_func(SwigClassUnderlyingCPRegType.klass, _wrap_UnderlyingCPRegType_allocate);
  rb_define_method(SwigClassUnderlyingCPRegType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCPRegType), -1);
  SwigClassUnderlyingCPRegType.mark = 0;
  SwigClassUnderlyingCPRegType.destroy = (void (*)(void *)) free_FIX_UnderlyingCPRegType;
  SwigClassUnderlyingCPRegType.trackObjects = 0;
  
  SwigClassSignatureLength.klass = rb_define_class_under(mQuickfix, "SignatureLength", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SignatureLength, (void *) &SwigClassSignatureLength);
  rb_define_alloc_func(SwigClassSignatureLength.klass, _wrap_SignatureLength_allocate);
  rb_define_method(SwigClassSignatureLength.klass, "initialize", VALUEFUNC(_wrap_new_SignatureLength), -1);
  SwigClassSignatureLength.mark = 0;
  SwigClassSignatureLength.destroy = (void (*)(void *)) free_FIX_SignatureLength;
  SwigClassSignatureLength.trackObjects = 0;
  
  SwigClassOrderQty.klass = rb_define_class_under(mQuickfix, "OrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderQty, (void *) &SwigClassOrderQty);
  rb_define_alloc_func(SwigClassOrderQty.klass, _wrap_OrderQty_allocate);
  rb_define_method(SwigClassOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_OrderQty), -1);
  SwigClassOrderQty.mark = 0;
  SwigClassOrderQty.destroy = (void (*)(void *)) free_FIX_OrderQty;
  SwigClassOrderQty.trackObjects = 0;
  
  SwigClassOriginalNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "OriginalNotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding, (void *) &SwigClassOriginalNotionalPercentageOutstanding);
  rb_define_alloc_func(SwigClassOriginalNotionalPercentageOutstanding.klass, _wrap_OriginalNotionalPercentageOutstanding_allocate);
  rb_define_method(SwigClassOriginalNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_OriginalNotionalPercentageOutstanding), -1);
  SwigClassOriginalNotionalPercentageOutstanding.mark = 0;
  SwigClassOriginalNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_OriginalNotionalPercentageOutstanding;
  SwigClassOriginalNotionalPercentageOutstanding.trackObjects = 0;
  
  SwigClassUnderlyingTimeUnit.klass = rb_define_class_under(mQuickfix, "UnderlyingTimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingTimeUnit, (void *) &SwigClassUnderlyingTimeUnit);
  rb_define_alloc_func(SwigClassUnderlyingTimeUnit.klass, _wrap_UnderlyingTimeUnit_allocate);
  rb_define_method(SwigClassUnderlyingTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingTimeUnit), -1);
  SwigClassUnderlyingTimeUnit.mark = 0;
  SwigClassUnderlyingTimeUnit.destroy = (void (*)(void *)) free_FIX_UnderlyingTimeUnit;
  SwigClassUnderlyingTimeUnit.trackObjects = 0;
  
  SwigClassEncodedHeadlineLen.klass = rb_define_class_under(mQuickfix, "EncodedHeadlineLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedHeadlineLen, (void *) &SwigClassEncodedHeadlineLen);
  rb_define_alloc_func(SwigClassEncodedHeadlineLen.klass, _wrap_EncodedHeadlineLen_allocate);
  rb_define_method(SwigClassEncodedHeadlineLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedHeadlineLen), -1);
  SwigClassEncodedHeadlineLen.mark = 0;
  SwigClassEncodedHeadlineLen.destroy = (void (*)(void *)) free_FIX_EncodedHeadlineLen;
  SwigClassEncodedHeadlineLen.trackObjects = 0;
  
  SwigClassNoRegistDtls.klass = rb_define_class_under(mQuickfix, "NoRegistDtls", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRegistDtls, (void *) &SwigClassNoRegistDtls);
  rb_define_alloc_func(SwigClassNoRegistDtls.klass, _wrap_NoRegistDtls_allocate);
  rb_define_method(SwigClassNoRegistDtls.klass, "initialize", VALUEFUNC(_wrap_new_NoRegistDtls), -1);
  SwigClassNoRegistDtls.mark = 0;
  SwigClassNoRegistDtls.destroy = (void (*)(void *)) free_FIX_NoRegistDtls;
  SwigClassNoRegistDtls.trackObjects = 0;
  
  SwigClassStrategyParameterValue.klass = rb_define_class_under(mQuickfix, "StrategyParameterValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrategyParameterValue, (void *) &SwigClassStrategyParameterValue);
  rb_define_alloc_func(SwigClassStrategyParameterValue.klass, _wrap_StrategyParameterValue_allocate);
  rb_define_method(SwigClassStrategyParameterValue.klass, "initialize", VALUEFUNC(_wrap_new_StrategyParameterValue), -1);
  SwigClassStrategyParameterValue.mark = 0;
  SwigClassStrategyParameterValue.destroy = (void (*)(void *)) free_FIX_StrategyParameterValue;
  SwigClassStrategyParameterValue.trackObjects = 0;
  
  SwigClassNoInstrumentParties.klass = rb_define_class_under(mQuickfix, "NoInstrumentParties", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoInstrumentParties, (void *) &SwigClassNoInstrumentParties);
  rb_define_alloc_func(SwigClassNoInstrumentParties.klass, _wrap_NoInstrumentParties_allocate);
  rb_define_method(SwigClassNoInstrumentParties.klass, "initialize", VALUEFUNC(_wrap_new_NoInstrumentParties), -1);
  SwigClassNoInstrumentParties.mark = 0;
  SwigClassNoInstrumentParties.destroy = (void (*)(void *)) free_FIX_NoInstrumentParties;
  SwigClassNoInstrumentParties.trackObjects = 0;
  
  SwigClassQuoteType.klass = rb_define_class_under(mQuickfix, "QuoteType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteType, (void *) &SwigClassQuoteType);
  rb_define_alloc_func(SwigClassQuoteType.klass, _wrap_QuoteType_allocate);
  rb_define_method(SwigClassQuoteType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteType), -1);
  SwigClassQuoteType.mark = 0;
  SwigClassQuoteType.destroy = (void (*)(void *)) free_FIX_QuoteType;
  SwigClassQuoteType.trackObjects = 0;
  
  SwigClassNoStrategyParameters.klass = rb_define_class_under(mQuickfix, "NoStrategyParameters", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStrategyParameters, (void *) &SwigClassNoStrategyParameters);
  rb_define_alloc_func(SwigClassNoStrategyParameters.klass, _wrap_NoStrategyParameters_allocate);
  rb_define_method(SwigClassNoStrategyParameters.klass, "initialize", VALUEFUNC(_wrap_new_NoStrategyParameters), -1);
  SwigClassNoStrategyParameters.mark = 0;
  SwigClassNoStrategyParameters.destroy = (void (*)(void *)) free_FIX_NoStrategyParameters;
  SwigClassNoStrategyParameters.trackObjects = 0;
  
  SwigClassIndividualAllocRejCode.klass = rb_define_class_under(mQuickfix, "IndividualAllocRejCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IndividualAllocRejCode, (void *) &SwigClassIndividualAllocRejCode);
  rb_define_alloc_func(SwigClassIndividualAllocRejCode.klass, _wrap_IndividualAllocRejCode_allocate);
  rb_define_method(SwigClassIndividualAllocRejCode.klass, "initialize", VALUEFUNC(_wrap_new_IndividualAllocRejCode), -1);
  SwigClassIndividualAllocRejCode.mark = 0;
  SwigClassIndividualAllocRejCode.destroy = (void (*)(void *)) free_FIX_IndividualAllocRejCode;
  SwigClassIndividualAllocRejCode.trackObjects = 0;
  
  SwigClassDiscretionInst.klass = rb_define_class_under(mQuickfix, "DiscretionInst", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionInst, (void *) &SwigClassDiscretionInst);
  rb_define_alloc_func(SwigClassDiscretionInst.klass, _wrap_DiscretionInst_allocate);
  rb_define_method(SwigClassDiscretionInst.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionInst), -1);
  SwigClassDiscretionInst.mark = 0;
  SwigClassDiscretionInst.destroy = (void (*)(void *)) free_FIX_DiscretionInst;
  SwigClassDiscretionInst.trackObjects = 0;
  
  SwigClassTargetPartyRole.klass = rb_define_class_under(mQuickfix, "TargetPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetPartyRole, (void *) &SwigClassTargetPartyRole);
  rb_define_alloc_func(SwigClassTargetPartyRole.klass, _wrap_TargetPartyRole_allocate);
  rb_define_method(SwigClassTargetPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_TargetPartyRole), -1);
  SwigClassTargetPartyRole.mark = 0;
  SwigClassTargetPartyRole.destroy = (void (*)(void *)) free_FIX_TargetPartyRole;
  SwigClassTargetPartyRole.trackObjects = 0;
  
  SwigClassCrossPrioritization.klass = rb_define_class_under(mQuickfix, "CrossPrioritization", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossPrioritization, (void *) &SwigClassCrossPrioritization);
  rb_define_alloc_func(SwigClassCrossPrioritization.klass, _wrap_CrossPrioritization_allocate);
  rb_define_method(SwigClassCrossPrioritization.klass, "initialize", VALUEFUNC(_wrap_new_CrossPrioritization), -1);
  SwigClassCrossPrioritization.mark = 0;
  SwigClassCrossPrioritization.destroy = (void (*)(void *)) free_FIX_CrossPrioritization;
  SwigClassCrossPrioritization.trackObjects = 0;
  
  SwigClassEncodedListStatusText.klass = rb_define_class_under(mQuickfix, "EncodedListStatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListStatusText, (void *) &SwigClassEncodedListStatusText);
  rb_define_alloc_func(SwigClassEncodedListStatusText.klass, _wrap_EncodedListStatusText_allocate);
  rb_define_method(SwigClassEncodedListStatusText.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListStatusText), -1);
  SwigClassEncodedListStatusText.mark = 0;
  SwigClassEncodedListStatusText.destroy = (void (*)(void *)) free_FIX_EncodedListStatusText;
  SwigClassEncodedListStatusText.trackObjects = 0;
  
  SwigClassIOIOthSvc.klass = rb_define_class_under(mQuickfix, "IOIOthSvc", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIOthSvc, (void *) &SwigClassIOIOthSvc);
  rb_define_alloc_func(SwigClassIOIOthSvc.klass, _wrap_IOIOthSvc_allocate);
  rb_define_method(SwigClassIOIOthSvc.klass, "initialize", VALUEFUNC(_wrap_new_IOIOthSvc), -1);
  SwigClassIOIOthSvc.mark = 0;
  SwigClassIOIOthSvc.destroy = (void (*)(void *)) free_FIX_IOIOthSvc;
  SwigClassIOIOthSvc.trackObjects = 0;
  
  SwigClassLegIssueDate.klass = rb_define_class_under(mQuickfix, "LegIssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIssueDate, (void *) &SwigClassLegIssueDate);
  rb_define_alloc_func(SwigClassLegIssueDate.klass, _wrap_LegIssueDate_allocate);
  rb_define_method(SwigClassLegIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_LegIssueDate), -1);
  SwigClassLegIssueDate.mark = 0;
  SwigClassLegIssueDate.destroy = (void (*)(void *)) free_FIX_LegIssueDate;
  SwigClassLegIssueDate.trackObjects = 0;
  
  SwigClassMDReqRejReason.klass = rb_define_class_under(mQuickfix, "MDReqRejReason", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDReqRejReason, (void *) &SwigClassMDReqRejReason);
  rb_define_alloc_func(SwigClassMDReqRejReason.klass, _wrap_MDReqRejReason_allocate);
  rb_define_method(SwigClassMDReqRejReason.klass, "initialize", VALUEFUNC(_wrap_new_MDReqRejReason), -1);
  SwigClassMDReqRejReason.mark = 0;
  SwigClassMDReqRejReason.destroy = (void (*)(void *)) free_FIX_MDReqRejReason;
  SwigClassMDReqRejReason.trackObjects = 0;
  
  SwigClassApplReqType.klass = rb_define_class_under(mQuickfix, "ApplReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReqType, (void *) &SwigClassApplReqType);
  rb_define_alloc_func(SwigClassApplReqType.klass, _wrap_ApplReqType_allocate);
  rb_define_method(SwigClassApplReqType.klass, "initialize", VALUEFUNC(_wrap_new_ApplReqType), -1);
  SwigClassApplReqType.mark = 0;
  SwigClassApplReqType.destroy = (void (*)(void *)) free_FIX_ApplReqType;
  SwigClassApplReqType.trackObjects = 0;
  
  SwigClassCountry.klass = rb_define_class_under(mQuickfix, "Country", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Country, (void *) &SwigClassCountry);
  rb_define_alloc_func(SwigClassCountry.klass, _wrap_Country_allocate);
  rb_define_method(SwigClassCountry.klass, "initialize", VALUEFUNC(_wrap_new_Country), -1);
  SwigClassCountry.mark = 0;
  SwigClassCountry.destroy = (void (*)(void *)) free_FIX_Country;
  SwigClassCountry.trackObjects = 0;
  
  SwigClassUnderlyingLegSecurityIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource, (void *) &SwigClassUnderlyingLegSecurityIDSource);
  rb_define_alloc_func(SwigClassUnderlyingLegSecurityIDSource.klass, _wrap_UnderlyingLegSecurityIDSource_allocate);
  rb_define_method(SwigClassUnderlyingLegSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityIDSource), -1);
  SwigClassUnderlyingLegSecurityIDSource.mark = 0;
  SwigClassUnderlyingLegSecurityIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityIDSource;
  SwigClassUnderlyingLegSecurityIDSource.trackObjects = 0;
  
  SwigClassFlexProductEligibilityIndicator.klass = rb_define_class_under(mQuickfix, "FlexProductEligibilityIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FlexProductEligibilityIndicator, (void *) &SwigClassFlexProductEligibilityIndicator);
  rb_define_alloc_func(SwigClassFlexProductEligibilityIndicator.klass, _wrap_FlexProductEligibilityIndicator_allocate);
  rb_define_method(SwigClassFlexProductEligibilityIndicator.klass, "initialize", VALUEFUNC(_wrap_new_FlexProductEligibilityIndicator), -1);
  SwigClassFlexProductEligibilityIndicator.mark = 0;
  SwigClassFlexProductEligibilityIndicator.destroy = (void (*)(void *)) free_FIX_FlexProductEligibilityIndicator;
  SwigClassFlexProductEligibilityIndicator.trackObjects = 0;
  
  SwigClassAggressorIndicator.klass = rb_define_class_under(mQuickfix, "AggressorIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AggressorIndicator, (void *) &SwigClassAggressorIndicator);
  rb_define_alloc_func(SwigClassAggressorIndicator.klass, _wrap_AggressorIndicator_allocate);
  rb_define_method(SwigClassAggressorIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AggressorIndicator), -1);
  SwigClassAggressorIndicator.mark = 0;
  SwigClassAggressorIndicator.destroy = (void (*)(void *)) free_FIX_AggressorIndicator;
  SwigClassAggressorIndicator.trackObjects = 0;
  
  SwigClassExecPriceAdjustment.klass = rb_define_class_under(mQuickfix, "ExecPriceAdjustment", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecPriceAdjustment, (void *) &SwigClassExecPriceAdjustment);
  rb_define_alloc_func(SwigClassExecPriceAdjustment.klass, _wrap_ExecPriceAdjustment_allocate);
  rb_define_method(SwigClassExecPriceAdjustment.klass, "initialize", VALUEFUNC(_wrap_new_ExecPriceAdjustment), -1);
  SwigClassExecPriceAdjustment.mark = 0;
  SwigClassExecPriceAdjustment.destroy = (void (*)(void *)) free_FIX_ExecPriceAdjustment;
  SwigClassExecPriceAdjustment.trackObjects = 0;
  
  SwigClassBusinessRejectReason.klass = rb_define_class_under(mQuickfix, "BusinessRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BusinessRejectReason, (void *) &SwigClassBusinessRejectReason);
  rb_define_alloc_func(SwigClassBusinessRejectReason.klass, _wrap_BusinessRejectReason_allocate);
  rb_define_method(SwigClassBusinessRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_BusinessRejectReason), -1);
  SwigClassBusinessRejectReason.mark = 0;
  SwigClassBusinessRejectReason.destroy = (void (*)(void *)) free_FIX_BusinessRejectReason;
  SwigClassBusinessRejectReason.trackObjects = 0;
  
  SwigClassTradeDate.klass = rb_define_class_under(mQuickfix, "TradeDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeDate, (void *) &SwigClassTradeDate);
  rb_define_alloc_func(SwigClassTradeDate.klass, _wrap_TradeDate_allocate);
  rb_define_method(SwigClassTradeDate.klass, "initialize", VALUEFUNC(_wrap_new_TradeDate), -1);
  SwigClassTradeDate.mark = 0;
  SwigClassTradeDate.destroy = (void (*)(void *)) free_FIX_TradeDate;
  SwigClassTradeDate.trackObjects = 0;
  
  SwigClassUnderlyingPutOrCall.klass = rb_define_class_under(mQuickfix, "UnderlyingPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPutOrCall, (void *) &SwigClassUnderlyingPutOrCall);
  rb_define_alloc_func(SwigClassUnderlyingPutOrCall.klass, _wrap_UnderlyingPutOrCall_allocate);
  rb_define_method(SwigClassUnderlyingPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPutOrCall), -1);
  SwigClassUnderlyingPutOrCall.mark = 0;
  SwigClassUnderlyingPutOrCall.destroy = (void (*)(void *)) free_FIX_UnderlyingPutOrCall;
  SwigClassUnderlyingPutOrCall.trackObjects = 0;
  
  SwigClassUnderlyingInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole, (void *) &SwigClassUnderlyingInstrumentPartyRole);
  rb_define_alloc_func(SwigClassUnderlyingInstrumentPartyRole.klass, _wrap_UnderlyingInstrumentPartyRole_allocate);
  rb_define_method(SwigClassUnderlyingInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartyRole), -1);
  SwigClassUnderlyingInstrumentPartyRole.mark = 0;
  SwigClassUnderlyingInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartyRole;
  SwigClassUnderlyingInstrumentPartyRole.trackObjects = 0;
  
  SwigClassDerivativePositionLimit.klass = rb_define_class_under(mQuickfix, "DerivativePositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePositionLimit, (void *) &SwigClassDerivativePositionLimit);
  rb_define_alloc_func(SwigClassDerivativePositionLimit.klass, _wrap_DerivativePositionLimit_allocate);
  rb_define_method(SwigClassDerivativePositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePositionLimit), -1);
  SwigClassDerivativePositionLimit.mark = 0;
  SwigClassDerivativePositionLimit.destroy = (void (*)(void *)) free_FIX_DerivativePositionLimit;
  SwigClassDerivativePositionLimit.trackObjects = 0;
  
  SwigClassTierCode.klass = rb_define_class_under(mQuickfix, "TierCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TierCode, (void *) &SwigClassTierCode);
  rb_define_alloc_func(SwigClassTierCode.klass, _wrap_TierCode_allocate);
  rb_define_method(SwigClassTierCode.klass, "initialize", VALUEFUNC(_wrap_new_TierCode), -1);
  SwigClassTierCode.mark = 0;
  SwigClassTierCode.destroy = (void (*)(void *)) free_FIX_TierCode;
  SwigClassTierCode.trackObjects = 0;
  
  SwigClassBookingType.klass = rb_define_class_under(mQuickfix, "BookingType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BookingType, (void *) &SwigClassBookingType);
  rb_define_alloc_func(SwigClassBookingType.klass, _wrap_BookingType_allocate);
  rb_define_method(SwigClassBookingType.klass, "initialize", VALUEFUNC(_wrap_new_BookingType), -1);
  SwigClassBookingType.mark = 0;
  SwigClassBookingType.destroy = (void (*)(void *)) free_FIX_BookingType;
  SwigClassBookingType.trackObjects = 0;
  
  SwigClassStipulationValue.klass = rb_define_class_under(mQuickfix, "StipulationValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StipulationValue, (void *) &SwigClassStipulationValue);
  rb_define_alloc_func(SwigClassStipulationValue.klass, _wrap_StipulationValue_allocate);
  rb_define_method(SwigClassStipulationValue.klass, "initialize", VALUEFUNC(_wrap_new_StipulationValue), -1);
  SwigClassStipulationValue.mark = 0;
  SwigClassStipulationValue.destroy = (void (*)(void *)) free_FIX_StipulationValue;
  SwigClassStipulationValue.trackObjects = 0;
  
  SwigClassSettlCurrBidFxRate.klass = rb_define_class_under(mQuickfix, "SettlCurrBidFxRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrBidFxRate, (void *) &SwigClassSettlCurrBidFxRate);
  rb_define_alloc_func(SwigClassSettlCurrBidFxRate.klass, _wrap_SettlCurrBidFxRate_allocate);
  rb_define_method(SwigClassSettlCurrBidFxRate.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrBidFxRate), -1);
  SwigClassSettlCurrBidFxRate.mark = 0;
  SwigClassSettlCurrBidFxRate.destroy = (void (*)(void *)) free_FIX_SettlCurrBidFxRate;
  SwigClassSettlCurrBidFxRate.trackObjects = 0;
  rb_define_singleton_method(mQuickfix, "BeginString_FIXT11", VALUEFUNC(_wrap_BeginString_FIXT11_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX50", VALUEFUNC(_wrap_BeginString_FIX50_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX44", VALUEFUNC(_wrap_BeginString_FIX44_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX43", VALUEFUNC(_wrap_BeginString_FIX43_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX42", VALUEFUNC(_wrap_BeginString_FIX42_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX41", VALUEFUNC(_wrap_BeginString_FIX41_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX40", VALUEFUNC(_wrap_BeginString_FIX40_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_TAG_NUMBER_TEXT", VALUEFUNC(_wrap_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REQUIRED_TAG_MISSING_TEXT", VALUEFUNC(_wrap_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT", VALUEFUNC(_wrap_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_UNDEFINED_TAG_TEXT", VALUEFUNC(_wrap_SessionRejectReason_UNDEFINED_TAG_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT", VALUEFUNC(_wrap_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_VALUE_IS_INCORRECT_TEXT", VALUEFUNC(_wrap_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT", VALUEFUNC(_wrap_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_DECRYPTION_PROBLEM_TEXT", VALUEFUNC(_wrap_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SIGNATURE_PROBLEM_TEXT", VALUEFUNC(_wrap_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_COMPID_PROBLEM_TEXT", VALUEFUNC(_wrap_SessionRejectReason_COMPID_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT", VALUEFUNC(_wrap_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_MSGTYPE_TEXT", VALUEFUNC(_wrap_SessionRejectReason_INVALID_MSGTYPE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT", VALUEFUNC(_wrap_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT", VALUEFUNC(_wrap_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT", VALUEFUNC(_wrap_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_OTHER_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_OTHER_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_ID_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_UNKNOWN_ID_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_SECURITY_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_NOT_AUTHORIZED_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_NOT_AUTHORIZED_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT", VALUEFUNC(_wrap_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryForm_BOOKENTRY", VALUEFUNC(_wrap_DeliveryForm_BOOKENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryForm_BEARER", VALUEFUNC(_wrap_DeliveryForm_BEARER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryForm_BOOK_ENTRY", VALUEFUNC(_wrap_DeliveryForm_BOOK_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_WAREHOUSE_RECAP", VALUEFUNC(_wrap_ExecRestatementReason_WAREHOUSE_RECAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE", VALUEFUNC(_wrap_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY", VALUEFUNC(_wrap_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_GT_CORPORATE_ACTION", VALUEFUNC(_wrap_ExecRestatementReason_GT_CORPORATE_ACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_PEG_REFRESH", VALUEFUNC(_wrap_ExecRestatementReason_PEG_REFRESH_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCELED_NOT_BEST", VALUEFUNC(_wrap_ExecRestatementReason_CANCELED_NOT_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCEL_ON_TRADING_HALT", VALUEFUNC(_wrap_ExecRestatementReason_CANCEL_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_VERBAL_CHANGE", VALUEFUNC(_wrap_ExecRestatementReason_VERBAL_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_OTHER", VALUEFUNC(_wrap_ExecRestatementReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_BROKER_OPTION", VALUEFUNC(_wrap_ExecRestatementReason_BROKER_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_REPRICING_OF_ORDER", VALUEFUNC(_wrap_ExecRestatementReason_REPRICING_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_MARKET", VALUEFUNC(_wrap_ExecRestatementReason_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_GT_RENEWAL", VALUEFUNC(_wrap_ExecRestatementReason_GT_RENEWAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDING_RELEASE", VALUEFUNC(_wrap_AllocIntermedReqType_PENDING_RELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDING_REVERSAL", VALUEFUNC(_wrap_AllocIntermedReqType_PENDING_REVERSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_ACCOUNT_LEVEL_REJECT", VALUEFUNC(_wrap_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_BLOCK_LEVEL_REJECT", VALUEFUNC(_wrap_AllocIntermedReqType_BLOCK_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDING_ACCEPT", VALUEFUNC(_wrap_AllocIntermedReqType_PENDING_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_ACCEPT", VALUEFUNC(_wrap_AllocIntermedReqType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListTypeSource_GICS", VALUEFUNC(_wrap_SecurityListTypeSource_GICS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListTypeSource_NAICS", VALUEFUNC(_wrap_SecurityListTypeSource_NAICS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListTypeSource_ICB", VALUEFUNC(_wrap_SecurityListTypeSource_ICB_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_OUTSTANDING_TRADES", VALUEFUNC(_wrap_CollInquiryQualifier_OUTSTANDING_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_PARTIALLY_ASSIGNED", VALUEFUNC(_wrap_CollInquiryQualifier_PARTIALLY_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_TRADE_DATE", VALUEFUNC(_wrap_CollInquiryQualifier_TRADE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_FULLY_ASSIGNED", VALUEFUNC(_wrap_CollInquiryQualifier_FULLY_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_SUBSTITUTION_ELIGIBLE", VALUEFUNC(_wrap_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_NOT_ASSIGNED", VALUEFUNC(_wrap_CollInquiryQualifier_NOT_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_COLLATERAL_INSTRUMENT", VALUEFUNC(_wrap_CollInquiryQualifier_COLLATERAL_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_TRADEDATE", VALUEFUNC(_wrap_CollInquiryQualifier_TRADEDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_COLLATERALINSTRUMENT", VALUEFUNC(_wrap_CollInquiryQualifier_COLLATERALINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_GC_INSTRUMENT", VALUEFUNC(_wrap_CollInquiryQualifier_GC_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_UPDATES_THE_OTHER_4", VALUEFUNC(_wrap_ContingencyType_ONE_UPDATES_THE_OTHER_4_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_TRIGGERS_THE_OTHER", VALUEFUNC(_wrap_ContingencyType_ONE_TRIGGERS_THE_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_CANCELS_THE_OTHER", VALUEFUNC(_wrap_ContingencyType_ONE_CANCELS_THE_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_UPDATES_THE_OTHER_3", VALUEFUNC(_wrap_ContingencyType_ONE_UPDATES_THE_OTHER_3_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_NEW", VALUEFUNC(_wrap_EmailType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_REPLY", VALUEFUNC(_wrap_EmailType_REPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_ADMIN_REPLY", VALUEFUNC(_wrap_EmailType_ADMIN_REPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQltyInd_MEDIUM", VALUEFUNC(_wrap_IOIQltyInd_MEDIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQltyInd_HIGH", VALUEFUNC(_wrap_IOIQltyInd_HIGH_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQltyInd_LOW", VALUEFUNC(_wrap_IOIQltyInd_LOW_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY", VALUEFUNC(_wrap_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY", VALUEFUNC(_wrap_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY", VALUEFUNC(_wrap_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_HOUSE_TRADER", VALUEFUNC(_wrap_AccountType_HOUSE_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS", VALUEFUNC(_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_FLOOR_TRADER", VALUEFUNC(_wrap_AccountType_FLOOR_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_JOINT_BACK_OFFICE_ACCOUNT", VALUEFUNC(_wrap_AccountType_JOINT_BACK_OFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED", VALUEFUNC(_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(_wrap_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_JOINT_BACKOFFICE_ACCOUNT", VALUEFUNC(_wrap_AccountType_JOINT_BACKOFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED", VALUEFUNC(_wrap_AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_ADDITIONAL_INFORMATION", VALUEFUNC(_wrap_HaltReasonInt_ADDITIONAL_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_NEWS_PENDING", VALUEFUNC(_wrap_HaltReasonInt_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_ORDER_INFLUX", VALUEFUNC(_wrap_HaltReasonInt_ORDER_INFLUX_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_NEWS_DISSEMINATION", VALUEFUNC(_wrap_HaltReasonInt_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_EQUIPMENT_CHANGEOVER", VALUEFUNC(_wrap_HaltReasonInt_EQUIPMENT_CHANGEOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_ORDER_IMBALANCE", VALUEFUNC(_wrap_HaltReasonInt_ORDER_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_106H_AND_106J_FIRMS", VALUEFUNC(_wrap_ClearingFeeIndicator_106H_AND_106J_FIRMS_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS", VALUEFUNC(_wrap_ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_LESSEE_106F_EMPLOYEES", VALUEFUNC(_wrap_ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER", VALUEFUNC(_wrap_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS", VALUEFUNC(_wrap_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_CBOE_MEMBER", VALUEFUNC(_wrap_ClearingFeeIndicator_CBOE_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES", VALUEFUNC(_wrap_ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR", VALUEFUNC(_wrap_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER", VALUEFUNC(_wrap_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES", VALUEFUNC(_wrap_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(_wrap_ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_DISCLOSED_STYLE", VALUEFUNC(_wrap_BidType_DISCLOSED_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_NO_BIDDING_PROCESS", VALUEFUNC(_wrap_BidType_NO_BIDDING_PROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_DISCLOSED_SYTLE", VALUEFUNC(_wrap_BidType_DISCLOSED_SYTLE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_NON_DISCLOSED_STYLE", VALUEFUNC(_wrap_BidType_NON_DISCLOSED_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PER_SHARE", VALUEFUNC(_wrap_QuotePriceType_PER_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR", VALUEFUNC(_wrap_QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR", VALUEFUNC(_wrap_QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_YIELD", VALUEFUNC(_wrap_QuotePriceType_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PREMIUM", VALUEFUNC(_wrap_QuotePriceType_PREMIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_TED_YIELD", VALUEFUNC(_wrap_QuotePriceType_TED_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_FIXED_AMOUNT", VALUEFUNC(_wrap_QuotePriceType_FIXED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_DISCOUNT", VALUEFUNC(_wrap_QuotePriceType_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_YIELD_SPREAD", VALUEFUNC(_wrap_QuotePriceType_YIELD_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_TED_PRICE", VALUEFUNC(_wrap_QuotePriceType_TED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PERCENT", VALUEFUNC(_wrap_QuotePriceType_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_SPREAD", VALUEFUNC(_wrap_QuotePriceType_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK", VALUEFUNC(_wrap_QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE", VALUEFUNC(_wrap_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_REVERSED_NET_PRICE", VALUEFUNC(_wrap_MultilegPriceMethod_REVERSED_NET_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_MULTIPLIED_PRICE", VALUEFUNC(_wrap_MultilegPriceMethod_MULTIPLIED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_INDIVIDUAL", VALUEFUNC(_wrap_MultilegPriceMethod_INDIVIDUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_YIELD_DIFFERENCE", VALUEFUNC(_wrap_MultilegPriceMethod_YIELD_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_NET_PRICE", VALUEFUNC(_wrap_MultilegPriceMethod_NET_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListMethod_PRE_LISTED_ONLY", VALUEFUNC(_wrap_ListMethod_PRE_LISTED_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ListMethod_USER_REQUESTED", VALUEFUNC(_wrap_ListMethod_USER_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MDImplicitDelete_NO", VALUEFUNC(_wrap_MDImplicitDelete_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "MDImplicitDelete_YES", VALUEFUNC(_wrap_MDImplicitDelete_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_TARGET_LIST", VALUEFUNC(_wrap_RoutingType_TARGET_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_TARGET_FIRM", VALUEFUNC(_wrap_RoutingType_TARGET_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_BLOCK_LIST", VALUEFUNC(_wrap_RoutingType_BLOCK_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_BLOCK_FIRM", VALUEFUNC(_wrap_RoutingType_BLOCK_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_AGENCY", VALUEFUNC(_wrap_BidTradeType_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_VWAP_GUARANTEE", VALUEFUNC(_wrap_BidTradeType_VWAP_GUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_RISK_TRADE", VALUEFUNC(_wrap_BidTradeType_RISK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_GUARANTEED_CLOSE", VALUEFUNC(_wrap_BidTradeType_GUARANTEED_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INCORRECT_ALLOCATED_QUANTITY", VALUEFUNC(_wrap_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER", VALUEFUNC(_wrap_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_ORDER_EXCEEDS_LIMIT", VALUEFUNC(_wrap_OrdRejReason_ORDER_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_EXCHANGE_CLOSED", VALUEFUNC(_wrap_OrdRejReason_EXCHANGE_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_SURVEILLENCE_OPTION", VALUEFUNC(_wrap_OrdRejReason_SURVEILLENCE_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN_ORDER", VALUEFUNC(_wrap_OrdRejReason_UNKNOWN_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC", VALUEFUNC(_wrap_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_DUPLICATE_ORDER", VALUEFUNC(_wrap_OrdRejReason_DUPLICATE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_TOO_LATE_TO_ENTER", VALUEFUNC(_wrap_OrdRejReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION", VALUEFUNC(_wrap_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INCORRECT_QUANTITY", VALUEFUNC(_wrap_OrdRejReason_INCORRECT_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INVALID_PRICE_INCREMENT", VALUEFUNC(_wrap_OrdRejReason_INVALID_PRICE_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN_ACCOUNT", VALUEFUNC(_wrap_OrdRejReason_UNKNOWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INVALID_INVESTOR_ID", VALUEFUNC(_wrap_OrdRejReason_INVALID_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN_SYMBOL", VALUEFUNC(_wrap_OrdRejReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_OTHER", VALUEFUNC(_wrap_OrdRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_BROKER", VALUEFUNC(_wrap_OrdRejReason_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_BROKER_OPTION", VALUEFUNC(_wrap_OrdRejReason_BROKER_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", VALUEFUNC(_wrap_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_TRADE_ALONG_REQUIRED", VALUEFUNC(_wrap_OrdRejReason_TRADE_ALONG_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_STALE_ORDER", VALUEFUNC(_wrap_OrdRejReason_STALE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_WEEKS", VALUEFUNC(_wrap_MaturityMonthYearIncrementUnits_WEEKS_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_MONTHS", VALUEFUNC(_wrap_MaturityMonthYearIncrementUnits_MONTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_YEARS", VALUEFUNC(_wrap_MaturityMonthYearIncrementUnits_YEARS_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_DAYS", VALUEFUNC(_wrap_MaturityMonthYearIncrementUnits_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayWhen_EXHAUST", VALUEFUNC(_wrap_DisplayWhen_EXHAUST_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayWhen_IMMEDIATE", VALUEFUNC(_wrap_DisplayWhen_IMMEDIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_END_SESSION", VALUEFUNC(_wrap_ApplQueueAction_END_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_QUEUE_FLUSHED", VALUEFUNC(_wrap_ApplQueueAction_QUEUE_FLUSHED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_OVERLAY_LAST", VALUEFUNC(_wrap_ApplQueueAction_OVERLAY_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_NO_ACTION_TAKEN", VALUEFUNC(_wrap_ApplQueueAction_NO_ACTION_TAKEN_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistTransType_REPLACE", VALUEFUNC(_wrap_RegistTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistTransType_NEW", VALUEFUNC(_wrap_RegistTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistTransType_CANCEL", VALUEFUNC(_wrap_RegistTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_HALFS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_HALFS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PER_SHARE", VALUEFUNC(_wrap_PriceType_PER_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR", VALUEFUNC(_wrap_PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR", VALUEFUNC(_wrap_PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_FOURTHS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_FOURTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_YIELD", VALUEFUNC(_wrap_PriceType_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_TED_YIELD", VALUEFUNC(_wrap_PriceType_TED_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PREMIUM", VALUEFUNC(_wrap_PriceType_PREMIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_FIXED_AMOUNT", VALUEFUNC(_wrap_PriceType_FIXED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_DISCOUNT", VALUEFUNC(_wrap_PriceType_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PERCENTAGE", VALUEFUNC(_wrap_PriceType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_EIGHTS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_EIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_SIXTEENTHS", VALUEFUNC(_wrap_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PER_UNIT", VALUEFUNC(_wrap_PriceType_PER_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_VARIABLE_CABINET_TRADE_PRICE", VALUEFUNC(_wrap_PriceType_VARIABLE_CABINET_TRADE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_TED_PRICE", VALUEFUNC(_wrap_PriceType_TED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_SPREAD", VALUEFUNC(_wrap_PriceType_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_FIXED_CABINET_TRADE_PRICE", VALUEFUNC(_wrap_PriceType_FIXED_CABINET_TRADE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK", VALUEFUNC(_wrap_PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligMode_PRELIMINARY", VALUEFUNC(_wrap_SettlObligMode_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligMode_FINAL", VALUEFUNC(_wrap_SettlObligMode_FINAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityUpdateAction_DELETE", VALUEFUNC(_wrap_SecurityUpdateAction_DELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityUpdateAction_ADD", VALUEFUNC(_wrap_SecurityUpdateAction_ADD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityUpdateAction_MODIFY", VALUEFUNC(_wrap_SecurityUpdateAction_MODIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_STOP_SUBSCRIBING", VALUEFUNC(_wrap_NetworkRequestType_STOP_SUBSCRIBING_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_SUBSCRIBE", VALUEFUNC(_wrap_NetworkRequestType_SUBSCRIBE_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_SNAPSHOT", VALUEFUNC(_wrap_NetworkRequestType_SNAPSHOT_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED", VALUEFUNC(_wrap_NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTION_VENUE", VALUEFUNC(_wrap_PartyRole_EXECUTION_VENUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLIENT_ID", VALUEFUNC(_wrap_PartyRole_CLIENT_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MARKET_DATA_ENTRY_ORIGINATOR", VALUEFUNC(_wrap_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDER_ORIGINATION_FIRM", VALUEFUNC(_wrap_PartyRole_ORDER_ORIGINATION_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_PLEDGEE_ACCOUNT", VALUEFUNC(_wrap_PartyRole_PLEDGEE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_TRADER", VALUEFUNC(_wrap_PartyRole_CONTRA_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MULTILATERAL_TRADING_FACILITY", VALUEFUNC(_wrap_PartyRole_MULTILATERAL_TRADING_FACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CENTRAL_REGISTRATION_DEPOSITORY", VALUEFUNC(_wrap_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REPORT_ORIGINATOR", VALUEFUNC(_wrap_PartyRole_REPORT_ORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_TRANSFER_TO_FIRM", VALUEFUNC(_wrap_PartyRole_TRANSFER_TO_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BROKERCLEARINGID", VALUEFUNC(_wrap_PartyRole_BROKERCLEARINGID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ASSET_MANAGER", VALUEFUNC(_wrap_PartyRole_ASSET_MANAGER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTRODUCING_BROKER", VALUEFUNC(_wrap_PartyRole_INTRODUCING_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATE_LENDING_FIRM", VALUEFUNC(_wrap_PartyRole_LOCATE_LENDING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_CLEARING_FIRM", VALUEFUNC(_wrap_PartyRole_CONTRA_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION", VALUEFUNC(_wrap_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CUSTODIAN", VALUEFUNC(_wrap_PartyRole_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_GIVEUP_CLEARING_FIRM", VALUEFUNC(_wrap_PartyRole_GIVEUP_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_TRADER", VALUEFUNC(_wrap_PartyRole_EXECUTING_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_UNIT", VALUEFUNC(_wrap_PartyRole_EXECUTING_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BROKER_OF_CREDIT", VALUEFUNC(_wrap_PartyRole_BROKER_OF_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDANT_CLEARING_FIRM", VALUEFUNC(_wrap_PartyRole_CORRESPONDANT_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SETTLEMENT_LOCATION", VALUEFUNC(_wrap_PartyRole_SETTLEMENT_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_THIRD_PARTY_ALLOCATION_FIRM", VALUEFUNC(_wrap_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDER_ORIGINATION_TRADER", VALUEFUNC(_wrap_PartyRole_ORDER_ORIGINATION_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_HOST_COMPETENT_AUTHORITY", VALUEFUNC(_wrap_PartyRole_HOST_COMPETENT_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDER_ENTRY_OPERATOR_ID", VALUEFUNC(_wrap_PartyRole_ORDER_ENTRY_OPERATOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SPONSORING_FIRM", VALUEFUNC(_wrap_PartyRole_SPONSORING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTRODUCING_FIRM", VALUEFUNC(_wrap_PartyRole_INTRODUCING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARING_FIRM", VALUEFUNC(_wrap_PartyRole_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_POSITION_ACCOUNT", VALUEFUNC(_wrap_PartyRole_CONTRA_POSITION_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INVESTOR_ID", VALUEFUNC(_wrap_PartyRole_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERING_TRADER", VALUEFUNC(_wrap_PartyRole_ENTERING_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATE", VALUEFUNC(_wrap_PartyRole_LOCATE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT", VALUEFUNC(_wrap_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY", VALUEFUNC(_wrap_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES", VALUEFUNC(_wrap_PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FORIEGN_FIRM", VALUEFUNC(_wrap_PartyRole_FORIEGN_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ACCEPTABLE_COUNTERPARTY", VALUEFUNC(_wrap_PartyRole_ACCEPTABLE_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CUSTOMER_ACCOUNT", VALUEFUNC(_wrap_PartyRole_CUSTOMER_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_POSITION_ACCOUNT", VALUEFUNC(_wrap_PartyRole_POSITION_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LIQUIDITY_PROVIDER", VALUEFUNC(_wrap_PartyRole_LIQUIDITY_PROVIDER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MARKET_MAKER", VALUEFUNC(_wrap_PartyRole_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_AGENT", VALUEFUNC(_wrap_PartyRole_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERING_UNIT", VALUEFUNC(_wrap_PartyRole_ENTERING_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FOREIGN_FIRM", VALUEFUNC(_wrap_PartyRole_FOREIGN_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARING_ACCOUNT", VALUEFUNC(_wrap_PartyRole_CLEARING_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_HOME_COMPETENT_AUTHORITY", VALUEFUNC(_wrap_PartyRole_HOME_COMPETENT_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERESTED_PARTY", VALUEFUNC(_wrap_PartyRole_INTERESTED_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SESSION_ID", VALUEFUNC(_wrap_PartyRole_SESSION_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REPORTING_INTERMEDIARY", VALUEFUNC(_wrap_PartyRole_REPORTING_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INVESTMENT_FIRM", VALUEFUNC(_wrap_PartyRole_INVESTMENT_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_TRADER_MNEMONIC", VALUEFUNC(_wrap_PartyRole_TRADER_MNEMONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERNAL_CARRY_ACCOUNT", VALUEFUNC(_wrap_PartyRole_INTERNAL_CARRY_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_FIRM", VALUEFUNC(_wrap_PartyRole_CONTRA_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDENT_BROKER", VALUEFUNC(_wrap_PartyRole_CORRESPONDENT_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARING_ORGANIZATION", VALUEFUNC(_wrap_PartyRole_CLEARING_ORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SUB_CUSTODIAN", VALUEFUNC(_wrap_PartyRole_SUB_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BUYER_SELLER", VALUEFUNC(_wrap_PartyRole_BUYER_SELLER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_STEP_OUT_FIRM", VALUEFUNC(_wrap_PartyRole_STEP_OUT_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MARKET_DATA_MARKET", VALUEFUNC(_wrap_PartyRole_MARKET_DATA_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXCHANGE", VALUEFUNC(_wrap_PartyRole_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLAIMING_ACCOUNT", VALUEFUNC(_wrap_PartyRole_CLAIMING_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SECONDARY_ACCOUNT_NUMBER", VALUEFUNC(_wrap_PartyRole_SECONDARY_ACCOUNT_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ALLOCATION_ENTITY", VALUEFUNC(_wrap_PartyRole_ALLOCATION_ENTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERMEDIARY", VALUEFUNC(_wrap_PartyRole_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_FIRM", VALUEFUNC(_wrap_PartyRole_EXECUTING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATION_ID", VALUEFUNC(_wrap_PartyRole_LOCATION_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_DESK_ID", VALUEFUNC(_wrap_PartyRole_DESK_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_SYSTEM", VALUEFUNC(_wrap_PartyRole_EXECUTING_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BENEFICIARY", VALUEFUNC(_wrap_PartyRole_BENEFICIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FUND_MANAGER_CLIENT_ID", VALUEFUNC(_wrap_PartyRole_FUND_MANAGER_CLIENT_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_INVESTOR_ID", VALUEFUNC(_wrap_PartyRole_CONTRA_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNACCEPTABLE_COUNTERPARTY", VALUEFUNC(_wrap_PartyRole_UNACCEPTABLE_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNDERLYING_CONTRA_FIRM", VALUEFUNC(_wrap_PartyRole_UNDERLYING_CONTRA_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_QUOTE_ORIGINATOR", VALUEFUNC(_wrap_PartyRole_QUOTE_ORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REGULATED_MARKET", VALUEFUNC(_wrap_PartyRole_REGULATED_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION", VALUEFUNC(_wrap_PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERING_FIRM", VALUEFUNC(_wrap_PartyRole_ENTERING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY", VALUEFUNC(_wrap_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SENDER_LOCATION", VALUEFUNC(_wrap_PartyRole_SENDER_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SYSTEMATIC_INTERNALISER", VALUEFUNC(_wrap_PartyRole_SYSTEMATIC_INTERNALISER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_EXCHANGE", VALUEFUNC(_wrap_PartyRole_CONTRA_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REGULATORY_BODY", VALUEFUNC(_wrap_PartyRole_REGULATORY_BODY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_PLEDGOR_ACCOUNT", VALUEFUNC(_wrap_PartyRole_PLEDGOR_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY", VALUEFUNC(_wrap_PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "AssignmentMethod_PRO_RATA", VALUEFUNC(_wrap_AssignmentMethod_PRO_RATA_get), 0);
  rb_define_singleton_method(mQuickfix, "AssignmentMethod_RANDOM", VALUEFUNC(_wrap_AssignmentMethod_RANDOM_get), 0);
  rb_define_singleton_method(mQuickfix, "AssignmentMethod_PRORATA", VALUEFUNC(_wrap_AssignmentMethod_PRORATA_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TZTIMEONLY", VALUEFUNC(_wrap_StrategyParameterType_TZTIMEONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MONTHYEAR", VALUEFUNC(_wrap_StrategyParameterType_MONTHYEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_PRICE", VALUEFUNC(_wrap_StrategyParameterType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_QTY", VALUEFUNC(_wrap_StrategyParameterType_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_BOOLEAN", VALUEFUNC(_wrap_StrategyParameterType_BOOLEAN_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MULTIPLECHARVALUE", VALUEFUNC(_wrap_StrategyParameterType_MULTIPLECHARVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_CHAR", VALUEFUNC(_wrap_StrategyParameterType_CHAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_NUMINGROUP", VALUEFUNC(_wrap_StrategyParameterType_NUMINGROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TAGNUM", VALUEFUNC(_wrap_StrategyParameterType_TAGNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_COUNTRY", VALUEFUNC(_wrap_StrategyParameterType_COUNTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TENOR", VALUEFUNC(_wrap_StrategyParameterType_TENOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LOCALMKTTIME", VALUEFUNC(_wrap_StrategyParameterType_LOCALMKTTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_INT", VALUEFUNC(_wrap_StrategyParameterType_INT_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LOCALMKTDATE", VALUEFUNC(_wrap_StrategyParameterType_LOCALMKTDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_EXCHANGE", VALUEFUNC(_wrap_StrategyParameterType_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LANGUAGE", VALUEFUNC(_wrap_StrategyParameterType_LANGUAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_PERCENTAGE", VALUEFUNC(_wrap_StrategyParameterType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LENGTH", VALUEFUNC(_wrap_StrategyParameterType_LENGTH_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TZTIMESTAMP", VALUEFUNC(_wrap_StrategyParameterType_TZTIMESTAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MULTIPLESTRINGVALUE", VALUEFUNC(_wrap_StrategyParameterType_MULTIPLESTRINGVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCTIMESTAMP", VALUEFUNC(_wrap_StrategyParameterType_UTCTIMESTAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_DATA", VALUEFUNC(_wrap_StrategyParameterType_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_CURRENCY", VALUEFUNC(_wrap_StrategyParameterType_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_STRING", VALUEFUNC(_wrap_StrategyParameterType_STRING_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_AMT", VALUEFUNC(_wrap_StrategyParameterType_AMT_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_FLOAT", VALUEFUNC(_wrap_StrategyParameterType_FLOAT_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCDATE", VALUEFUNC(_wrap_StrategyParameterType_UTCDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCTIMEONLY", VALUEFUNC(_wrap_StrategyParameterType_UTCTIMEONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_SEQNUM", VALUEFUNC(_wrap_StrategyParameterType_SEQNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCDATEONLY", VALUEFUNC(_wrap_StrategyParameterType_UTCDATEONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_PRICEOFFSET", VALUEFUNC(_wrap_StrategyParameterType_PRICEOFFSET_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PGP_DES_MD5", VALUEFUNC(_wrap_EncryptMethod_PGP_DES_MD5_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PKCS_DES", VALUEFUNC(_wrap_EncryptMethod_PKCS_DES_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PKCS", VALUEFUNC(_wrap_EncryptMethod_PKCS_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PGP_DES", VALUEFUNC(_wrap_EncryptMethod_PGP_DES_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_NONE", VALUEFUNC(_wrap_EncryptMethod_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_DES", VALUEFUNC(_wrap_EncryptMethod_DES_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_NONE_OTHER", VALUEFUNC(_wrap_EncryptMethod_NONE_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PEM_DES_MD5", VALUEFUNC(_wrap_EncryptMethod_PEM_DES_MD5_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_ACCRUED_COUPON_AMOUNT", VALUEFUNC(_wrap_PosAmtType_ACCRUED_COUPON_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_PREMIUM_AMOUNT", VALUEFUNC(_wrap_PosAmtType_PREMIUM_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET", VALUEFUNC(_wrap_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TOTAL_BANKED_AMOUNT", VALUEFUNC(_wrap_PosAmtType_TOTAL_BANKED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT", VALUEFUNC(_wrap_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_SETTLEMENT_VALUE", VALUEFUNC(_wrap_PosAmtType_SETTLEMENT_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_CASH_AMOUNT", VALUEFUNC(_wrap_PosAmtType_CASH_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INITIAL_TRADE_COUPON_AMOUNT", VALUEFUNC(_wrap_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTAL_ACCRUED_COUPON", VALUEFUNC(_wrap_PosAmtType_INCREMENTAL_ACCRUED_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_VALUE_ADJUSTED_AMOUNT", VALUEFUNC(_wrap_PosAmtType_VALUE_ADJUSTED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT", VALUEFUNC(_wrap_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_COLLATERALIZED_MARK_TO_MARKET", VALUEFUNC(_wrap_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_CASH_RESIDUAL_AMOUNT", VALUEFUNC(_wrap_PosAmtType_CASH_RESIDUAL_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_COMPENSATION_AMOUNT", VALUEFUNC(_wrap_PosAmtType_COMPENSATION_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TRADE_VARIATION_AMOUNT", VALUEFUNC(_wrap_PosAmtType_TRADE_VARIATION_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_COUPON_AMOUNT", VALUEFUNC(_wrap_PosAmtType_COUPON_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TOTAL_COLLATERALIZED_AMOUNT", VALUEFUNC(_wrap_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT", VALUEFUNC(_wrap_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ResetSeqNumFlag_NO", VALUEFUNC(_wrap_ResetSeqNumFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ResetSeqNumFlag_YES", VALUEFUNC(_wrap_ResetSeqNumFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED", VALUEFUNC(_wrap_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_DESTINATION_REQUESTED", VALUEFUNC(_wrap_CollInquiryResult_INVALID_DESTINATION_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY", VALUEFUNC(_wrap_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE", VALUEFUNC(_wrap_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_SUCCESSFUL", VALUEFUNC(_wrap_CollInquiryResult_SUCCESSFUL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_OTHER", VALUEFUNC(_wrap_CollInquiryResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED", VALUEFUNC(_wrap_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT", VALUEFUNC(_wrap_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_PARTIES", VALUEFUNC(_wrap_CollInquiryResult_INVALID_PARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED", VALUEFUNC(_wrap_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED", VALUEFUNC(_wrap_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_DECLINED", VALUEFUNC(_wrap_CollAsgnRespType_DECLINED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_RECEIVED", VALUEFUNC(_wrap_CollAsgnRespType_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_REJECTED", VALUEFUNC(_wrap_CollAsgnRespType_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_ACCEPTED", VALUEFUNC(_wrap_CollAsgnRespType_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "UnsolicitedIndicator_NO", VALUEFUNC(_wrap_UnsolicitedIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "UnsolicitedIndicator_YES", VALUEFUNC(_wrap_UnsolicitedIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_INVALID_PRICE", VALUEFUNC(_wrap_QuoteEntryRejectReason_INVALID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY", VALUEFUNC(_wrap_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(_wrap_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT", VALUEFUNC(_wrap_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_EXCHANGE", VALUEFUNC(_wrap_QuoteEntryRejectReason_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_UNKNOWN_SYMBOL", VALUEFUNC(_wrap_QuoteEntryRejectReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD", VALUEFUNC(_wrap_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_UNKNOWN_QUOTE", VALUEFUNC(_wrap_QuoteEntryRejectReason_UNKNOWN_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_DUPLICATE_QUOTE", VALUEFUNC(_wrap_QuoteEntryRejectReason_DUPLICATE_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_PROPRIETARY", VALUEFUNC(_wrap_OrderCapacity_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_RISKLESS_PRINCIPAL", VALUEFUNC(_wrap_OrderCapacity_RISKLESS_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_AGENT_FOR_OTHER_MEMBER", VALUEFUNC(_wrap_OrderCapacity_AGENT_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_PRINCIPAL", VALUEFUNC(_wrap_OrderCapacity_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_AGENCY", VALUEFUNC(_wrap_OrderCapacity_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_INDIVIDUAL", VALUEFUNC(_wrap_OrderCapacity_INDIVIDUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_FOR_UNDERLYING", VALUEFUNC(_wrap_QuoteAckStatus_CANCELED_FOR_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_ALL", VALUEFUNC(_wrap_QuoteAckStatus_CANCELED_ALL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE", VALUEFUNC(_wrap_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_REJECTED", VALUEFUNC(_wrap_QuoteAckStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_FOR_SYMBOL", VALUEFUNC(_wrap_QuoteAckStatus_CANCELED_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_ACCEPTED", VALUEFUNC(_wrap_QuoteAckStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_CHANGE_PASSWORD_FOR_USER", VALUEFUNC(_wrap_UserRequestType_CHANGE_PASSWORD_FOR_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_CHANGEPASSWORDFORUSER", VALUEFUNC(_wrap_UserRequestType_CHANGEPASSWORDFORUSER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOGOFFUSER", VALUEFUNC(_wrap_UserRequestType_LOGOFFUSER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOG_OFF_USER", VALUEFUNC(_wrap_UserRequestType_LOG_OFF_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS", VALUEFUNC(_wrap_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOGONUSER", VALUEFUNC(_wrap_UserRequestType_LOGONUSER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOG_ON_USER", VALUEFUNC(_wrap_UserRequestType_LOG_ON_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_REPLACE", VALUEFUNC(_wrap_TradeReportTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_NEW", VALUEFUNC(_wrap_TradeReportTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_REVERSE", VALUEFUNC(_wrap_TradeReportTransType_REVERSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_CANCEL", VALUEFUNC(_wrap_TradeReportTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE", VALUEFUNC(_wrap_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_RELEASE", VALUEFUNC(_wrap_TradeReportTransType_RELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_CROSS", VALUEFUNC(_wrap_AdvSide_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_TRADE", VALUEFUNC(_wrap_AdvSide_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_BUY", VALUEFUNC(_wrap_AdvSide_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_SELL", VALUEFUNC(_wrap_AdvSide_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "CoveredOrUncovered_COVERED", VALUEFUNC(_wrap_CoveredOrUncovered_COVERED_get), 0);
  rb_define_singleton_method(mQuickfix, "CoveredOrUncovered_UNCOVERED", VALUEFUNC(_wrap_CoveredOrUncovered_UNCOVERED_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_TFM", VALUEFUNC(_wrap_AcctIDSource_TFM_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_BIC", VALUEFUNC(_wrap_AcctIDSource_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_OTHER", VALUEFUNC(_wrap_AcctIDSource_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_OMGEO", VALUEFUNC(_wrap_AcctIDSource_OMGEO_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_DTCC_CODE", VALUEFUNC(_wrap_AcctIDSource_DTCC_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_SID_CODE", VALUEFUNC(_wrap_AcctIDSource_SID_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA", VALUEFUNC(_wrap_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_ALL_TRADES", VALUEFUNC(_wrap_TradeRequestType_ALL_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST", VALUEFUNC(_wrap_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA", VALUEFUNC(_wrap_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA", VALUEFUNC(_wrap_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_HALTED", VALUEFUNC(_wrap_TradSesStatus_HALTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_REQUEST_REJECTED", VALUEFUNC(_wrap_TradSesStatus_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_OPEN", VALUEFUNC(_wrap_TradSesStatus_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_PRE_OPEN", VALUEFUNC(_wrap_TradSesStatus_PRE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_UNKNOWN", VALUEFUNC(_wrap_TradSesStatus_UNKNOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_PRE_CLOSE", VALUEFUNC(_wrap_TradSesStatus_PRE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_CLOSED", VALUEFUNC(_wrap_TradSesStatus_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_LAST_PEG", VALUEFUNC(_wrap_PegPriceType_LAST_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_PRIMARY_PEG", VALUEFUNC(_wrap_PegPriceType_PRIMARY_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_OPENING_PEG", VALUEFUNC(_wrap_PegPriceType_OPENING_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER", VALUEFUNC(_wrap_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_TRAILING_STOP_PEG", VALUEFUNC(_wrap_PegPriceType_TRAILING_STOP_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_PEG_TO_LIMIT_PRICE", VALUEFUNC(_wrap_PegPriceType_PEG_TO_LIMIT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_MID_PRICE_PEG", VALUEFUNC(_wrap_PegPriceType_MID_PRICE_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_MARKET_PEG", VALUEFUNC(_wrap_PegPriceType_MARKET_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_PEG_TO_VWAP", VALUEFUNC(_wrap_PegPriceType_PEG_TO_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_NO_AVAILABLE_STREAM", VALUEFUNC(_wrap_StreamAsgnRejReason_NO_AVAILABLE_STREAM_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE", VALUEFUNC(_wrap_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_UNKNOWN_CLIENT", VALUEFUNC(_wrap_StreamAsgnRejReason_UNKNOWN_CLIENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR", VALUEFUNC(_wrap_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_OTHER", VALUEFUNC(_wrap_StreamAsgnRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT", VALUEFUNC(_wrap_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_PREMIUM_STYLE", VALUEFUNC(_wrap_ValuationMethod_PREMIUM_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_CDS_IN_DELIVERY", VALUEFUNC(_wrap_ValuationMethod_CDS_IN_DELIVERY_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON", VALUEFUNC(_wrap_ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET", VALUEFUNC(_wrap_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_SPECIFIED_TRADING_SESSION", VALUEFUNC(_wrap_TriggerType_SPECIFIED_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_NEXT_AUCTION", VALUEFUNC(_wrap_TriggerType_NEXT_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_PRICE_MOVEMENT", VALUEFUNC(_wrap_TriggerType_PRICE_MOVEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_PARTIAL_EXECUTION", VALUEFUNC(_wrap_TriggerType_PARTIAL_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_LOCAL", VALUEFUNC(_wrap_PriceProtectionScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_NONE", VALUEFUNC(_wrap_PriceProtectionScope_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_GLOBAL", VALUEFUNC(_wrap_PriceProtectionScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_NATIONAL", VALUEFUNC(_wrap_PriceProtectionScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALID_PARTY_INFORMATION", VALUEFUNC(_wrap_TradeReportRejectReason_INVALID_PARTY_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES", VALUEFUNC(_wrap_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALID_PARTY_ONFORMATION", VALUEFUNC(_wrap_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_UNKNOWN_INSTRUMENT", VALUEFUNC(_wrap_TradeReportRejectReason_UNKNOWN_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_SUCCESSFUL", VALUEFUNC(_wrap_TradeReportRejectReason_SUCCESSFUL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_OTHER", VALUEFUNC(_wrap_TradeReportRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALID_TRADE_TYPE", VALUEFUNC(_wrap_TradeReportRejectReason_INVALID_TRADE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_NEWSPAPER_LIST", VALUEFUNC(_wrap_SecurityListType_NEWSPAPER_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_TRADING_LIST", VALUEFUNC(_wrap_SecurityListType_TRADING_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_INDUSTRY_CLASSIFICATION", VALUEFUNC(_wrap_SecurityListType_INDUSTRY_CLASSIFICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_MARKET", VALUEFUNC(_wrap_SecurityListType_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_QUOTE_LOCKED", VALUEFUNC(_wrap_QuoteRejectReason_QUOTE_LOCKED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_PRICE", VALUEFUNC(_wrap_QuoteRejectReason_INVALID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY", VALUEFUNC(_wrap_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(_wrap_QuoteRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_EXCHANGE", VALUEFUNC(_wrap_QuoteRejectReason_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_UNKNOWN_SYMBOL", VALUEFUNC(_wrap_QuoteRejectReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_OTHER", VALUEFUNC(_wrap_QuoteRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_BID_ASK_SPREAD", VALUEFUNC(_wrap_QuoteRejectReason_INVALID_BID_ASK_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_UNKNOWN_QUOTE", VALUEFUNC(_wrap_QuoteRejectReason_UNKNOWN_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", VALUEFUNC(_wrap_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_DUPLICATE_QUOTE", VALUEFUNC(_wrap_QuoteRejectReason_DUPLICATE_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", VALUEFUNC(_wrap_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT", VALUEFUNC(_wrap_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PossResend_NO", VALUEFUNC(_wrap_PossResend_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PossResend_YES", VALUEFUNC(_wrap_PossResend_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_SHARES", VALUEFUNC(_wrap_QuantityType_SHARES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_CURRENTFACE", VALUEFUNC(_wrap_QuantityType_CURRENTFACE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_PAR", VALUEFUNC(_wrap_QuantityType_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_BONDS", VALUEFUNC(_wrap_QuantityType_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_ORIGINALFACE", VALUEFUNC(_wrap_QuantityType_ORIGINALFACE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_CONTRACTS", VALUEFUNC(_wrap_QuantityType_CONTRACTS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_OTHER", VALUEFUNC(_wrap_QuantityType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_CURRENCY", VALUEFUNC(_wrap_QuantityType_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE", VALUEFUNC(_wrap_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE", VALUEFUNC(_wrap_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE", VALUEFUNC(_wrap_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE", VALUEFUNC(_wrap_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE", VALUEFUNC(_wrap_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT", VALUEFUNC(_wrap_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_NOT_IMPLIED", VALUEFUNC(_wrap_ImpliedMarketIndicator_NOT_IMPLIED_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_IMPLIED_OUT", VALUEFUNC(_wrap_ImpliedMarketIndicator_IMPLIED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_IMPLIED_IN", VALUEFUNC(_wrap_ImpliedMarketIndicator_IMPLIED_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestType_AUTOMATIC", VALUEFUNC(_wrap_QuoteRequestType_AUTOMATIC_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestType_MANUAL", VALUEFUNC(_wrap_QuoteRequestType_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA", VALUEFUNC(_wrap_SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA", VALUEFUNC(_wrap_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE", VALUEFUNC(_wrap_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_VALID_REQUEST", VALUEFUNC(_wrap_SecurityRequestResult_VALID_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST", VALUEFUNC(_wrap_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED", VALUEFUNC(_wrap_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ISSUER_HOLDING", VALUEFUNC(_wrap_OrderRestrictions_ISSUER_HOLDING_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY", VALUEFUNC(_wrap_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_NON_ALGORITHMIC", VALUEFUNC(_wrap_OrderRestrictions_NON_ALGORITHMIC_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE", VALUEFUNC(_wrap_OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_NON_INDEX_ARBITRAGE", VALUEFUNC(_wrap_OrderRestrictions_NON_INDEX_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY", VALUEFUNC(_wrap_OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_PROGRAM_TRADE", VALUEFUNC(_wrap_OrderRestrictions_PROGRAM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ISSUE_PRICE_STABILIZATION", VALUEFUNC(_wrap_OrderRestrictions_ISSUE_PRICE_STABILIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_CROSS", VALUEFUNC(_wrap_OrderRestrictions_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE", VALUEFUNC(_wrap_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_FOREIGN_ENTITY", VALUEFUNC(_wrap_OrderRestrictions_FOREIGN_ENTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_INDEX_ARBITRAGE", VALUEFUNC(_wrap_OrderRestrictions_INDEX_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT", VALUEFUNC(_wrap_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ALGORITHMIC", VALUEFUNC(_wrap_OrderRestrictions_ALGORITHMIC_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY", VALUEFUNC(_wrap_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_RISKLESS_ARBITRAGE", VALUEFUNC(_wrap_OrderRestrictions_RISKLESS_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_COMPETING_MARKET_MAKER", VALUEFUNC(_wrap_OrderRestrictions_COMPETING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION", VALUEFUNC(_wrap_ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN", VALUEFUNC(_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW", VALUEFUNC(_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3", VALUEFUNC(_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_IMMEDIATE", VALUEFUNC(_wrap_ListExecInstType_IMMEDIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4", VALUEFUNC(_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5", VALUEFUNC(_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP", VALUEFUNC(_wrap_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION", VALUEFUNC(_wrap_ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_FED_WIRE", VALUEFUNC(_wrap_DistribPaymentMethod_FED_WIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_EUROCLEAR", VALUEFUNC(_wrap_DistribPaymentMethod_EUROCLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_ACH_CREDIT", VALUEFUNC(_wrap_DistribPaymentMethod_ACH_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_TELEGRAPHIC_TRANSFER", VALUEFUNC(_wrap_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_FEDWIRE", VALUEFUNC(_wrap_DistribPaymentMethod_FEDWIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_CHEQUE", VALUEFUNC(_wrap_DistribPaymentMethod_CHEQUE_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_DIRECT_CREDIT", VALUEFUNC(_wrap_DistribPaymentMethod_DIRECT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_CREST", VALUEFUNC(_wrap_DistribPaymentMethod_CREST_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM", VALUEFUNC(_wrap_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_CLEARSTREAM", VALUEFUNC(_wrap_DistribPaymentMethod_CLEARSTREAM_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_BPAY", VALUEFUNC(_wrap_DistribPaymentMethod_BPAY_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_NSCC", VALUEFUNC(_wrap_DistribPaymentMethod_NSCC_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS", VALUEFUNC(_wrap_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_REINVEST_IN_FUND", VALUEFUNC(_wrap_DistribPaymentMethod_REINVEST_IN_FUND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderHandlingInstSource_NASD_OATS", VALUEFUNC(_wrap_OrderHandlingInstSource_NASD_OATS_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_AFFIRMED", VALUEFUNC(_wrap_AffirmStatus_AFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED", VALUEFUNC(_wrap_AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_RECEIVED", VALUEFUNC(_wrap_AffirmStatus_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT", VALUEFUNC(_wrap_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT", VALUEFUNC(_wrap_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER", VALUEFUNC(_wrap_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_ALL_OTHER", VALUEFUNC(_wrap_OrigCustOrderCapacity_ALL_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocMethod_GUARANTOR", VALUEFUNC(_wrap_AllocMethod_GUARANTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocMethod_AUTOMATIC", VALUEFUNC(_wrap_AllocMethod_AUTOMATIC_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocMethod_MANUAL", VALUEFUNC(_wrap_AllocMethod_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ALL_ORDERS", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_REQUEST_REJECTED", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT", VALUEFUNC(_wrap_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER", VALUEFUNC(_wrap_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER", VALUEFUNC(_wrap_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE", VALUEFUNC(_wrap_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN", VALUEFUNC(_wrap_SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_PROPRIETARY", VALUEFUNC(_wrap_ExDestinationIDSource_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER", VALUEFUNC(_wrap_ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_BIC", VALUEFUNC(_wrap_ExDestinationIDSource_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_MIC", VALUEFUNC(_wrap_ExDestinationIDSource_MIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_ISO_COUNTRY_CODE", VALUEFUNC(_wrap_ExDestinationIDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID", VALUEFUNC(_wrap_SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_SYMBOL", VALUEFUNC(_wrap_SecurityListRequestType_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE", VALUEFUNC(_wrap_SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_TRADINGSESSIONID", VALUEFUNC(_wrap_SecurityListRequestType_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_ALL_SECURITIES", VALUEFUNC(_wrap_SecurityListRequestType_ALL_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_PRODUCT", VALUEFUNC(_wrap_SecurityListRequestType_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_TIME_WARNING", VALUEFUNC(_wrap_CollAsgnReason_TIME_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_ADVERSE_TAX_EVENT", VALUEFUNC(_wrap_CollAsgnReason_ADVERSE_TAX_EVENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_MARGIN_DEFICIENCY", VALUEFUNC(_wrap_CollAsgnReason_MARGIN_DEFICIENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_SCHEDULED", VALUEFUNC(_wrap_CollAsgnReason_SCHEDULED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_INITIAL", VALUEFUNC(_wrap_CollAsgnReason_INITIAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_FORWARD_COLLATERAL_DEMAND", VALUEFUNC(_wrap_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_EVENT_OF_DEFAULT", VALUEFUNC(_wrap_CollAsgnReason_EVENT_OF_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_MARGIN_EXCESS", VALUEFUNC(_wrap_CollAsgnReason_MARGIN_EXCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlPriceType_FINAL", VALUEFUNC(_wrap_SettlPriceType_FINAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlPriceType_THEORETICAL", VALUEFUNC(_wrap_SettlPriceType_THEORETICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DealingCapacity_RISKLESS_PRINCIPAL", VALUEFUNC(_wrap_DealingCapacity_RISKLESS_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DealingCapacity_PRINCIPAL", VALUEFUNC(_wrap_DealingCapacity_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DealingCapacity_AGENT", VALUEFUNC(_wrap_DealingCapacity_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSourceType_SECONDARY", VALUEFUNC(_wrap_RateSourceType_SECONDARY_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSourceType_PRIMARY", VALUEFUNC(_wrap_RateSourceType_PRIMARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AggregatedBook_NO", VALUEFUNC(_wrap_AggregatedBook_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "AggregatedBook_YES", VALUEFUNC(_wrap_AggregatedBook_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosQtyStatus_SUBMITTED", VALUEFUNC(_wrap_PosQtyStatus_SUBMITTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosQtyStatus_REJECTED", VALUEFUNC(_wrap_PosQtyStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosQtyStatus_ACCEPTED", VALUEFUNC(_wrap_PosQtyStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionStatusRequest", VALUEFUNC(_wrap_MsgType_TradingSessionStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListStatus", VALUEFUNC(_wrap_MsgType_ListStatus_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Email", VALUEFUNC(_wrap_MsgType_Email_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListExecute", VALUEFUNC(_wrap_MsgType_ListExecute_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Confirmation", VALUEFUNC(_wrap_MsgType_Confirmation_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderMultileg", VALUEFUNC(_wrap_MsgType_NewOrderMultileg_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataIncrementalRefresh", VALUEFUNC(_wrap_MsgType_MarketDataIncrementalRefresh_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReport", VALUEFUNC(_wrap_MsgType_TradeCaptureReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RequestForPositionsAck", VALUEFUNC(_wrap_MsgType_RequestForPositionsAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_StreamAssignmentRequest", VALUEFUNC(_wrap_MsgType_StreamAssignmentRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityListRequest", VALUEFUNC(_wrap_MsgType_SecurityListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralReport", VALUEFUNC(_wrap_MsgType_CollateralReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PositionMaintenanceReport", VALUEFUNC(_wrap_MsgType_PositionMaintenanceReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PositionReport", VALUEFUNC(_wrap_MsgType_PositionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_StreamAssignmentReportACK", VALUEFUNC(_wrap_MsgType_StreamAssignmentReportACK_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_UserRequest", VALUEFUNC(_wrap_MsgType_UserRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PositionMaintenanceRequest", VALUEFUNC(_wrap_MsgType_PositionMaintenanceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NetworkCounterpartySystemStatusResponse", VALUEFUNC(_wrap_MsgType_NetworkCounterpartySystemStatusResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderCross", VALUEFUNC(_wrap_MsgType_NewOrderCross_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AdjustedPositionReport", VALUEFUNC(_wrap_MsgType_AdjustedPositionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Logon", VALUEFUNC(_wrap_MsgType_Logon_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_IOI", VALUEFUNC(_wrap_MsgType_IOI_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListStrikePrice", VALUEFUNC(_wrap_MsgType_ListStrikePrice_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_BidRequest", VALUEFUNC(_wrap_MsgType_BidRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionStatus", VALUEFUNC(_wrap_MsgType_TradingSessionStatus_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RegistrationInstructionsResponse", VALUEFUNC(_wrap_MsgType_RegistrationInstructionsResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Advertisement", VALUEFUNC(_wrap_MsgType_Advertisement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MassQuote", VALUEFUNC(_wrap_MsgType_MassQuote_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Logout", VALUEFUNC(_wrap_MsgType_Logout_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationReport", VALUEFUNC(_wrap_MsgType_AllocationReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityDefinitionUpdateReport", VALUEFUNC(_wrap_MsgType_SecurityDefinitionUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListStatusRequest", VALUEFUNC(_wrap_MsgType_ListStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_BusinessMessageReject", VALUEFUNC(_wrap_MsgType_BusinessMessageReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ConfirmationAck", VALUEFUNC(_wrap_MsgType_ConfirmationAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_XMLnonFIX", VALUEFUNC(_wrap_MsgType_XMLnonFIX_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TestRequest", VALUEFUNC(_wrap_MsgType_TestRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityList", VALUEFUNC(_wrap_MsgType_SecurityList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListCancelRequest", VALUEFUNC(_wrap_MsgType_ListCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_News", VALUEFUNC(_wrap_MsgType_News_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionListUpdateReport", VALUEFUNC(_wrap_MsgType_TradingSessionListUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Heartbeat", VALUEFUNC(_wrap_MsgType_Heartbeat_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteAcknowledgement", VALUEFUNC(_wrap_MsgType_QuoteAcknowledgement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationReportAck", VALUEFUNC(_wrap_MsgType_AllocationReportAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ConfirmationRequest", VALUEFUNC(_wrap_MsgType_ConfirmationRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassActionReport", VALUEFUNC(_wrap_MsgType_OrderMassActionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralInquiry", VALUEFUNC(_wrap_MsgType_CollateralInquiry_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityTypeRequest", VALUEFUNC(_wrap_MsgType_SecurityTypeRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderList", VALUEFUNC(_wrap_MsgType_NewOrderList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ExecutionAcknowledgement", VALUEFUNC(_wrap_MsgType_ExecutionAcknowledgement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionListRequest", VALUEFUNC(_wrap_MsgType_TradingSessionListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityTypes", VALUEFUNC(_wrap_MsgType_SecurityTypes_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDefinition", VALUEFUNC(_wrap_MsgType_MarketDefinition_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SequenceReset", VALUEFUNC(_wrap_MsgType_SequenceReset_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralResponse", VALUEFUNC(_wrap_MsgType_CollateralResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MassQuoteAcknowledgement", VALUEFUNC(_wrap_MsgType_MassQuoteAcknowledgement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteResponse", VALUEFUNC(_wrap_MsgType_QuoteResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteStatusRequest", VALUEFUNC(_wrap_MsgType_QuoteStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteCancel", VALUEFUNC(_wrap_MsgType_QuoteCancel_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ContraryIntentionReport", VALUEFUNC(_wrap_MsgType_ContraryIntentionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CrossOrderCancelRequest", VALUEFUNC(_wrap_MsgType_CrossOrderCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderSingle", VALUEFUNC(_wrap_MsgType_NewOrderSingle_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DerivativeSecurityListRequest", VALUEFUNC(_wrap_MsgType_DerivativeSecurityListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralRequest", VALUEFUNC(_wrap_MsgType_CollateralRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_UserNotification", VALUEFUNC(_wrap_MsgType_UserNotification_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_UserResponse", VALUEFUNC(_wrap_MsgType_UserResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DontKnowTrade", VALUEFUNC(_wrap_MsgType_DontKnowTrade_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReportAck", VALUEFUNC(_wrap_MsgType_TradeCaptureReportAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ApplicationMessageRequest", VALUEFUNC(_wrap_MsgType_ApplicationMessageRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MultilegOrderCancelReplace", VALUEFUNC(_wrap_MsgType_MultilegOrderCancelReplace_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderCancelReject", VALUEFUNC(_wrap_MsgType_OrderCancelReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ExecutionReport", VALUEFUNC(_wrap_MsgType_ExecutionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteStatusReport", VALUEFUNC(_wrap_MsgType_QuoteStatusReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ResendRequest", VALUEFUNC(_wrap_MsgType_ResendRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Quote", VALUEFUNC(_wrap_MsgType_Quote_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SettlementInstructionRequest", VALUEFUNC(_wrap_MsgType_SettlementInstructionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityListUpdateReport", VALUEFUNC(_wrap_MsgType_SecurityListUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationInstructionAlert", VALUEFUNC(_wrap_MsgType_AllocationInstructionAlert_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReportRequestAck", VALUEFUNC(_wrap_MsgType_TradeCaptureReportRequestAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationInstruction", VALUEFUNC(_wrap_MsgType_AllocationInstruction_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Allocation", VALUEFUNC(_wrap_MsgType_Allocation_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RegistrationInstructions", VALUEFUNC(_wrap_MsgType_RegistrationInstructions_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityDefinition", VALUEFUNC(_wrap_MsgType_SecurityDefinition_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityDefinitionRequest", VALUEFUNC(_wrap_MsgType_SecurityDefinitionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityStatus", VALUEFUNC(_wrap_MsgType_SecurityStatus_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ApplicationMessageReport", VALUEFUNC(_wrap_MsgType_ApplicationMessageReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DerivativeSecurityList", VALUEFUNC(_wrap_MsgType_DerivativeSecurityList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NetworkCounterpartySystemStatusRequest", VALUEFUNC(_wrap_MsgType_NetworkCounterpartySystemStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDefinitionRequest", VALUEFUNC(_wrap_MsgType_MarketDefinitionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Reject", VALUEFUNC(_wrap_MsgType_Reject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DerivativeSecurityListUpdateReport", VALUEFUNC(_wrap_MsgType_DerivativeSecurityListUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteRequestReject", VALUEFUNC(_wrap_MsgType_QuoteRequestReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassStatusRequest", VALUEFUNC(_wrap_MsgType_OrderMassStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ApplicationMessageRequestAck", VALUEFUNC(_wrap_MsgType_ApplicationMessageRequestAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityStatusRequest", VALUEFUNC(_wrap_MsgType_SecurityStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDefinitionUpdateReport", VALUEFUNC(_wrap_MsgType_MarketDefinitionUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CrossOrderCancelReplaceRequest", VALUEFUNC(_wrap_MsgType_CrossOrderCancelReplaceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassCancelReport", VALUEFUNC(_wrap_MsgType_OrderMassCancelReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AssignmentReport", VALUEFUNC(_wrap_MsgType_AssignmentReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_BidResponse", VALUEFUNC(_wrap_MsgType_BidResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RequestForPositions", VALUEFUNC(_wrap_MsgType_RequestForPositions_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SettlementObligationReport", VALUEFUNC(_wrap_MsgType_SettlementObligationReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassCancelRequest", VALUEFUNC(_wrap_MsgType_OrderMassCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionList", VALUEFUNC(_wrap_MsgType_TradingSessionList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderStatusRequest", VALUEFUNC(_wrap_MsgType_OrderStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralAssignment", VALUEFUNC(_wrap_MsgType_CollateralAssignment_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_StreamAssignmentReport", VALUEFUNC(_wrap_MsgType_StreamAssignmentReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassActionRequest", VALUEFUNC(_wrap_MsgType_OrderMassActionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationAck", VALUEFUNC(_wrap_MsgType_AllocationAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteRequest", VALUEFUNC(_wrap_MsgType_QuoteRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralInquiryAck", VALUEFUNC(_wrap_MsgType_CollateralInquiryAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataSnapshotFullRefresh", VALUEFUNC(_wrap_MsgType_MarketDataSnapshotFullRefresh_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SettlementInstructions", VALUEFUNC(_wrap_MsgType_SettlementInstructions_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderCancelReplaceRequest", VALUEFUNC(_wrap_MsgType_OrderCancelReplaceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReportRequest", VALUEFUNC(_wrap_MsgType_TradeCaptureReportRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RFQRequest", VALUEFUNC(_wrap_MsgType_RFQRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderCancelRequest", VALUEFUNC(_wrap_MsgType_OrderCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MultilegOrderCancelReplaceRequest", VALUEFUNC(_wrap_MsgType_MultilegOrderCancelReplaceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationInstructionAck", VALUEFUNC(_wrap_MsgType_AllocationInstructionAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataRequest", VALUEFUNC(_wrap_MsgType_MarketDataRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataRequestReject", VALUEFUNC(_wrap_MsgType_MarketDataRequestReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_SINGLE_SECURITY", VALUEFUNC(_wrap_MultiLegReportingType_SINGLE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_MULTI_LEG_SECURITY", VALUEFUNC(_wrap_MultiLegReportingType_MULTI_LEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY", VALUEFUNC(_wrap_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY", VALUEFUNC(_wrap_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_EXCHANGE_SYMBOL", VALUEFUNC(_wrap_IDSource_EXCHANGE_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_RIC_CODE", VALUEFUNC(_wrap_IDSource_RIC_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_ISO_CURRENCY_CODE", VALUEFUNC(_wrap_IDSource_ISO_CURRENCY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_ISIN_NUMBER", VALUEFUNC(_wrap_IDSource_ISIN_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_SEDOL", VALUEFUNC(_wrap_IDSource_SEDOL_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_ISO_COUNTRY_CODE", VALUEFUNC(_wrap_IDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_CONSOLIDATED_TAPE_ASSOCIATION", VALUEFUNC(_wrap_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_QUIK", VALUEFUNC(_wrap_IDSource_QUIK_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_CUSIP", VALUEFUNC(_wrap_IDSource_CUSIP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_NEW", VALUEFUNC(_wrap_OrdStatus_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_CALCULATED", VALUEFUNC(_wrap_OrdStatus_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_CANCEL", VALUEFUNC(_wrap_OrdStatus_PENDING_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_CANCEL_REPLACE", VALUEFUNC(_wrap_OrdStatus_PENDING_CANCEL_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_NEW", VALUEFUNC(_wrap_OrdStatus_PENDING_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_STOPPED", VALUEFUNC(_wrap_OrdStatus_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_FILLED", VALUEFUNC(_wrap_OrdStatus_FILLED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_REPLACE", VALUEFUNC(_wrap_OrdStatus_PENDING_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_CANCELED", VALUEFUNC(_wrap_OrdStatus_CANCELED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_ACCEPTED_FOR_BIDDING", VALUEFUNC(_wrap_OrdStatus_ACCEPTED_FOR_BIDDING_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_SUSPENDED", VALUEFUNC(_wrap_OrdStatus_SUSPENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_REJECTED", VALUEFUNC(_wrap_OrdStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PARTIALLY_FILLED", VALUEFUNC(_wrap_OrdStatus_PARTIALLY_FILLED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_EXPIRED", VALUEFUNC(_wrap_OrdStatus_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_REPLACED", VALUEFUNC(_wrap_OrdStatus_REPLACED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_DONE_FOR_DAY", VALUEFUNC(_wrap_OrdStatus_DONE_FOR_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustomerOrFirm_FIRM", VALUEFUNC(_wrap_CustomerOrFirm_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "CustomerOrFirm_CUSTOMER", VALUEFUNC(_wrap_CustomerOrFirm_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_DELTA_MINUS", VALUEFUNC(_wrap_AdjustmentType_DELTA_MINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_DELTA_PLUS", VALUEFUNC(_wrap_AdjustmentType_DELTA_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_FINAL", VALUEFUNC(_wrap_AdjustmentType_FINAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION", VALUEFUNC(_wrap_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "AsOfIndicator_TRUE", VALUEFUNC(_wrap_AsOfIndicator_TRUE_get), 0);
  rb_define_singleton_method(mQuickfix, "AsOfIndicator_FALSE", VALUEFUNC(_wrap_AsOfIndicator_FALSE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_MARKET", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_CFICODE", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_CANCEL_FOR_SECURITY_ISSUER", VALUEFUNC(_wrap_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_PRODUCT", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(_wrap_MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "VenueType_PIT", VALUEFUNC(_wrap_VenueType_PIT_get), 0);
  rb_define_singleton_method(mQuickfix, "VenueType_EX_PIT", VALUEFUNC(_wrap_VenueType_EX_PIT_get), 0);
  rb_define_singleton_method(mQuickfix, "VenueType_ELECTRONIC", VALUEFUNC(_wrap_VenueType_ELECTRONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionType_CANCEL_ORDERS", VALUEFUNC(_wrap_MassActionType_CANCEL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionType_RELEASE_ORDERS_FROM_SUSPENSION", VALUEFUNC(_wrap_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionType_SUSPEND_ORDERS", VALUEFUNC(_wrap_MassActionType_SUSPEND_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_SUCCESSFUL_COMPLETION", VALUEFUNC(_wrap_PosMaintResult_SUCCESSFUL_COMPLETION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_OTHER", VALUEFUNC(_wrap_PosMaintResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_REJECTED", VALUEFUNC(_wrap_PosMaintResult_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIShares_MEDIUM", VALUEFUNC(_wrap_IOIShares_MEDIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIShares_LARGE", VALUEFUNC(_wrap_IOIShares_LARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIShares_SMALL", VALUEFUNC(_wrap_IOIShares_SMALL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_PRICE", VALUEFUNC(_wrap_PegOffsetType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_PRICE_TIER", VALUEFUNC(_wrap_PegOffsetType_PRICE_TIER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_TICKS", VALUEFUNC(_wrap_PegOffsetType_TICKS_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_BASIS_POINTS", VALUEFUNC(_wrap_PegOffsetType_BASIS_POINTS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED", VALUEFUNC(_wrap_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_OTHER", VALUEFUNC(_wrap_MassCancelRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING", VALUEFUNC(_wrap_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_INBAND", VALUEFUNC(_wrap_ResponseTransportType_INBAND_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_OUT_OF_BAND", VALUEFUNC(_wrap_ResponseTransportType_OUT_OF_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER", VALUEFUNC(_wrap_ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM", VALUEFUNC(_wrap_ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID", VALUEFUNC(_wrap_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatusRejReason_OTHER", VALUEFUNC(_wrap_TradSesStatusRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_EXECUTION_TIME", VALUEFUNC(_wrap_TrdRegTimestampType_EXECUTION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_TIME_IN", VALUEFUNC(_wrap_TrdRegTimestampType_TIME_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_SUBMISSION_TO_CLEARING", VALUEFUNC(_wrap_TrdRegTimestampType_SUBMISSION_TO_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_DESK_RECEIPT", VALUEFUNC(_wrap_TrdRegTimestampType_DESK_RECEIPT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_BROKER_RECEIPT", VALUEFUNC(_wrap_TrdRegTimestampType_BROKER_RECEIPT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_BROKER_EXECUTION", VALUEFUNC(_wrap_TrdRegTimestampType_BROKER_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_TIME_OUT", VALUEFUNC(_wrap_TrdRegTimestampType_TIME_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX50SP1", VALUEFUNC(_wrap_ApplVerID_FIX50SP1_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX27", VALUEFUNC(_wrap_ApplVerID_FIX27_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX50SP2", VALUEFUNC(_wrap_ApplVerID_FIX50SP2_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX50", VALUEFUNC(_wrap_ApplVerID_FIX50_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX40", VALUEFUNC(_wrap_ApplVerID_FIX40_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX41", VALUEFUNC(_wrap_ApplVerID_FIX41_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX30", VALUEFUNC(_wrap_ApplVerID_FIX30_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX42", VALUEFUNC(_wrap_ApplVerID_FIX42_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX43", VALUEFUNC(_wrap_ApplVerID_FIX43_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX44", VALUEFUNC(_wrap_ApplVerID_FIX44_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_MANUAL_ORDER_BEST_EXECUTION", VALUEFUNC(_wrap_HandlInst_MANUAL_ORDER_BEST_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION", VALUEFUNC(_wrap_HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK", VALUEFUNC(_wrap_HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_POST_TRADING", VALUEFUNC(_wrap_TradingSessionSubID_POST_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_INTRADAY_AUCTION", VALUEFUNC(_wrap_TradingSessionSubID_INTRADAY_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_PRE_TRADING", VALUEFUNC(_wrap_TradingSessionSubID_PRE_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_QUIESCENT", VALUEFUNC(_wrap_TradingSessionSubID_QUIESCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_3", VALUEFUNC(_wrap_TradingSessionSubID_3_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_OPENING_OR_OPENING_AUCTION", VALUEFUNC(_wrap_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION", VALUEFUNC(_wrap_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SWAP_VALUE_FACTOR", VALUEFUNC(_wrap_MDEntryType_SWAP_VALUE_FACTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_COMPOSITE_UNDERLYING_PRICE", VALUEFUNC(_wrap_MDEntryType_COMPOSITE_UNDERLYING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SESSION_HIGH_BID", VALUEFUNC(_wrap_MDEntryType_SESSION_HIGH_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OPEN_INTEREST", VALUEFUNC(_wrap_MDEntryType_OPEN_INTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CLOSING_PRICE", VALUEFUNC(_wrap_MDEntryType_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_PRIOR_SETTLE_PRICE", VALUEFUNC(_wrap_MDEntryType_PRIOR_SETTLE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADING_SESSION_VWAP_PRICE", VALUEFUNC(_wrap_MDEntryType_TRADING_SESSION_VWAP_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADING_SESSION_LOW_PRICE", VALUEFUNC(_wrap_MDEntryType_TRADING_SESSION_LOW_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLE_HIGH_PRICE", VALUEFUNC(_wrap_MDEntryType_SETTLE_HIGH_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_IMBALANCE", VALUEFUNC(_wrap_MDEntryType_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_FIXING_PRICE", VALUEFUNC(_wrap_MDEntryType_FIXING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CASH_RATE", VALUEFUNC(_wrap_MDEntryType_CASH_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OPENING_PRICE", VALUEFUNC(_wrap_MDEntryType_OPENING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADE", VALUEFUNC(_wrap_MDEntryType_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS", VALUEFUNC(_wrap_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SIMULATED_SELL_PRICE", VALUEFUNC(_wrap_MDEntryType_SIMULATED_SELL_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_EMPTY_BOOK", VALUEFUNC(_wrap_MDEntryType_EMPTY_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_AUCTION_CLEARING_PRICE", VALUEFUNC(_wrap_MDEntryType_AUCTION_CLEARING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_BID", VALUEFUNC(_wrap_MDEntryType_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_RECOVERY_RATE_FOR_SHORT", VALUEFUNC(_wrap_MDEntryType_RECOVERY_RATE_FOR_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SIMULATED_BUY_PRICE", VALUEFUNC(_wrap_MDEntryType_SIMULATED_BUY_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_EARLY_PRICES", VALUEFUNC(_wrap_MDEntryType_EARLY_PRICES_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADING_SESSION_HIGH_PRICE", VALUEFUNC(_wrap_MDEntryType_TRADING_SESSION_HIGH_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_INDEX_VALUE", VALUEFUNC(_wrap_MDEntryType_INDEX_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_RECOVERY_RATE_FOR_LONG", VALUEFUNC(_wrap_MDEntryType_RECOVERY_RATE_FOR_LONG_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS", VALUEFUNC(_wrap_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_MID_PRICE", VALUEFUNC(_wrap_MDEntryType_MID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_RECOVERY_RATE", VALUEFUNC(_wrap_MDEntryType_RECOVERY_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS", VALUEFUNC(_wrap_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS", VALUEFUNC(_wrap_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_MARGIN_RATE", VALUEFUNC(_wrap_MDEntryType_MARGIN_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLE_LOW_PRICE", VALUEFUNC(_wrap_MDEntryType_SETTLE_LOW_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SESSION_LOW_OFFER", VALUEFUNC(_wrap_MDEntryType_SESSION_LOW_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADE_VOLUME", VALUEFUNC(_wrap_MDEntryType_TRADE_VOLUME_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLEMENT_PRICE", VALUEFUNC(_wrap_MDEntryType_SETTLEMENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OFFER", VALUEFUNC(_wrap_MDEntryType_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegMoveType_FLOATING", VALUEFUNC(_wrap_PegMoveType_FLOATING_get), 0);
  rb_define_singleton_method(mQuickfix, "PegMoveType_FIXED", VALUEFUNC(_wrap_PegMoveType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID", VALUEFUNC(_wrap_AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_NO_AVERAGE_PRICING", VALUEFUNC(_wrap_AvgPxIndicator_NO_AVERAGE_PRICING_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID", VALUEFUNC(_wrap_AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID", VALUEFUNC(_wrap_AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_WAIVER_AGREEMENT", VALUEFUNC(_wrap_CancellationRights_NO_WAIVER_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_M", VALUEFUNC(_wrap_CancellationRights_NO_M_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_N", VALUEFUNC(_wrap_CancellationRights_NO_N_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_INSTITUTIONAL", VALUEFUNC(_wrap_CancellationRights_NO_INSTITUTIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_YES", VALUEFUNC(_wrap_CancellationRights_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_O", VALUEFUNC(_wrap_CancellationRights_NO_O_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_EXECUTION_ONLY", VALUEFUNC(_wrap_CancellationRights_NO_EXECUTION_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE", VALUEFUNC(_wrap_ExecPriceType_CREATION_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT", VALUEFUNC(_wrap_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT", VALUEFUNC(_wrap_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT", VALUEFUNC(_wrap_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT", VALUEFUNC(_wrap_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT", VALUEFUNC(_wrap_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_BID_PRICE", VALUEFUNC(_wrap_ExecPriceType_BID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_SINGLE_PRICE", VALUEFUNC(_wrap_ExecPriceType_SINGLE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT", VALUEFUNC(_wrap_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE", VALUEFUNC(_wrap_ExecPriceType_OFFER_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_PHONE_FOR_INSTRUCTIONS", VALUEFUNC(_wrap_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_SSI_DB_IDS_PROVIDED", VALUEFUNC(_wrap_AllocSettlInstType_SSI_DB_IDS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_FULL_DETAILS_PROVIDED", VALUEFUNC(_wrap_AllocSettlInstType_FULL_DETAILS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED", VALUEFUNC(_wrap_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS", VALUEFUNC(_wrap_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_AVERAGE_PRICE", VALUEFUNC(_wrap_StatsType_AVERAGE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_HIGH", VALUEFUNC(_wrap_StatsType_HIGH_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_EXCHANGE_LAST", VALUEFUNC(_wrap_StatsType_EXCHANGE_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_TURNOVER", VALUEFUNC(_wrap_StatsType_TURNOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMode_SIMULATED", VALUEFUNC(_wrap_TradSesMode_SIMULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMode_PRODUCTION", VALUEFUNC(_wrap_TradSesMode_PRODUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMode_TESTING", VALUEFUNC(_wrap_TradSesMode_TESTING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_INSTITUTIONS_INSTRUCTIONS", VALUEFUNC(_wrap_SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_BROKERS_INSTRUCTIONS", VALUEFUNC(_wrap_SettlInstSource_BROKERS_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_INVESTOR", VALUEFUNC(_wrap_SettlInstSource_INVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_DIFFERENCE", VALUEFUNC(_wrap_ExpType_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_FINAL_WILL_BE_EXERCISED", VALUEFUNC(_wrap_ExpType_FINAL_WILL_BE_EXERCISED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_NON_AUTO_EXERCISE", VALUEFUNC(_wrap_ExpType_NON_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_CONTRARY_INTENTION", VALUEFUNC(_wrap_ExpType_CONTRARY_INTENTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_AUTO_EXERCISE", VALUEFUNC(_wrap_ExpType_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_REPLACE", VALUEFUNC(_wrap_SettlInstTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_NEW", VALUEFUNC(_wrap_SettlInstTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_RESTATE", VALUEFUNC(_wrap_SettlInstTransType_RESTATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_CANCEL", VALUEFUNC(_wrap_SettlInstTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_DESTINATION_REQUESTED", VALUEFUNC(_wrap_TradeRequestResult_INVALID_DESTINATION_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST", VALUEFUNC(_wrap_TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST", VALUEFUNC(_wrap_TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_SUCCESSFUL", VALUEFUNC(_wrap_TradeRequestResult_SUCCESSFUL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_OTHER", VALUEFUNC(_wrap_TradeRequestResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT", VALUEFUNC(_wrap_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_PARTIES", VALUEFUNC(_wrap_TradeRequestResult_INVALID_PARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED", VALUEFUNC(_wrap_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_NOT_AUTHORIZED", VALUEFUNC(_wrap_TradeRequestResult_NOT_AUTHORIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED", VALUEFUNC(_wrap_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED", VALUEFUNC(_wrap_TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TestMessageIndicator_NO", VALUEFUNC(_wrap_TestMessageIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "TestMessageIndicator_YES", VALUEFUNC(_wrap_TestMessageIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE", VALUEFUNC(_wrap_ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE", VALUEFUNC(_wrap_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN", VALUEFUNC(_wrap_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS", VALUEFUNC(_wrap_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_OTHER", VALUEFUNC(_wrap_AllocCancReplaceReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT", VALUEFUNC(_wrap_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_DUPLICATE_CLORDID", VALUEFUNC(_wrap_CxlRejReason_DUPLICATE_CLORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE", VALUEFUNC(_wrap_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_DUPLICATE_CLORDID_RECEIVED", VALUEFUNC(_wrap_CxlRejReason_DUPLICATE_CLORDID_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_UNKNOWN_ORDER", VALUEFUNC(_wrap_CxlRejReason_UNKNOWN_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_TOO_LATE_TO_CANCEL", VALUEFUNC(_wrap_CxlRejReason_TOO_LATE_TO_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_INVALID_PRICE_INCREMENT", VALUEFUNC(_wrap_CxlRejReason_INVALID_PRICE_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ORIGORDMODTIME", VALUEFUNC(_wrap_CxlRejReason_ORIGORDMODTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_OTHER", VALUEFUNC(_wrap_CxlRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_BROKER", VALUEFUNC(_wrap_CxlRejReason_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_BROKER_OPTION", VALUEFUNC(_wrap_CxlRejReason_BROKER_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST", VALUEFUNC(_wrap_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS", VALUEFUNC(_wrap_CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", VALUEFUNC(_wrap_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER", VALUEFUNC(_wrap_CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_SPECIFIED_MARKET_PARTICIPANTS", VALUEFUNC(_wrap_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_ALL_MARKET_MAKERS", VALUEFUNC(_wrap_RespondentType_ALL_MARKET_MAKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_ALL_MARKET_PARTICIPANTS", VALUEFUNC(_wrap_RespondentType_ALL_MARKET_PARTICIPANTS_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_PRIMARY_MARKET_MAKER", VALUEFUNC(_wrap_RespondentType_PRIMARY_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_NO_MATCHING_ORDER", VALUEFUNC(_wrap_DKReason_NO_MATCHING_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_PRICE_EXCEEDS_LIMIT", VALUEFUNC(_wrap_DKReason_PRICE_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_QUANTITY_EXCEEDS_ORDER", VALUEFUNC(_wrap_DKReason_QUANTITY_EXCEEDS_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_UNKNOWN_SYMBOL", VALUEFUNC(_wrap_DKReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_OTHER", VALUEFUNC(_wrap_DKReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_WRONG_SIDE", VALUEFUNC(_wrap_DKReason_WRONG_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_CALCULATION_DIFFERENCE", VALUEFUNC(_wrap_DKReason_CALCULATION_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_DEFAULT", VALUEFUNC(_wrap_PositionEffect_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_CLOSE", VALUEFUNC(_wrap_PositionEffect_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN", VALUEFUNC(_wrap_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_OPEN", VALUEFUNC(_wrap_PositionEffect_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_FIFO", VALUEFUNC(_wrap_PositionEffect_FIFO_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_ROLLED", VALUEFUNC(_wrap_PositionEffect_ROLLED_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerAction_ACTIVATE", VALUEFUNC(_wrap_TriggerAction_ACTIVATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerAction_MODIFY", VALUEFUNC(_wrap_TriggerAction_MODIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerAction_CANCEL", VALUEFUNC(_wrap_TriggerAction_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLUDE_FROM_ALL_NETTING", VALUEFUNC(_wrap_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_AUTOMATIC_POSTING_MODE", VALUEFUNC(_wrap_ClearingInstruction_AUTOMATIC_POSTING_MODE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_MULTILATERAL_NETTING", VALUEFUNC(_wrap_ClearingInstruction_MULTILATERAL_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY", VALUEFUNC(_wrap_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_AUTOMATIC_GIVE_UP_MODE", VALUEFUNC(_wrap_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_CUSTOMER_TRADE", VALUEFUNC(_wrap_ClearingInstruction_CUSTOMER_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EX_CLEARING", VALUEFUNC(_wrap_ClearingInstruction_EX_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY", VALUEFUNC(_wrap_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_BILATERAL_NETTING_ONLY", VALUEFUNC(_wrap_ClearingInstruction_BILATERAL_NETTING_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_PROCESS_NORMALLY", VALUEFUNC(_wrap_ClearingInstruction_PROCESS_NORMALLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_SPECIAL_TRADE", VALUEFUNC(_wrap_ClearingInstruction_SPECIAL_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_MANUAL_MODE", VALUEFUNC(_wrap_ClearingInstruction_MANUAL_MODE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR", VALUEFUNC(_wrap_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE", VALUEFUNC(_wrap_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_SELF_CLEARING", VALUEFUNC(_wrap_ClearingInstruction_SELF_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_SESSION_OPEN", VALUEFUNC(_wrap_OpenCloseSettlFlag_SESSION_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_EXPECTED_ENTRY", VALUEFUNC(_wrap_OpenCloseSettlFlag_EXPECTED_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_DAILY_OPEN", VALUEFUNC(_wrap_OpenCloseSettlFlag_DAILY_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE", VALUEFUNC(_wrap_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY", VALUEFUNC(_wrap_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY", VALUEFUNC(_wrap_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionMoveType_FLOATING", VALUEFUNC(_wrap_DiscretionMoveType_FLOATING_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionMoveType_FIXED", VALUEFUNC(_wrap_DiscretionMoveType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateType_INCREMENTAL_REFRESH", VALUEFUNC(_wrap_MDUpdateType_INCREMENTAL_REFRESH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateType_FULL_REFRESH", VALUEFUNC(_wrap_MDUpdateType_FULL_REFRESH_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_MINUS_TICK", VALUEFUNC(_wrap_TickDirection_MINUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_ZERO_PLUS_TICK", VALUEFUNC(_wrap_TickDirection_ZERO_PLUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_ZERO_MINUS_TICK", VALUEFUNC(_wrap_TickDirection_ZERO_MINUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_PLUS_TICK", VALUEFUNC(_wrap_TickDirection_PLUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MARK_TO_MARKET_YIELD", VALUEFUNC(_wrap_YieldType_MARK_TO_MARKET_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_MATURITY", VALUEFUNC(_wrap_YieldType_YIELD_TO_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS", VALUEFUNC(_wrap_YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PREVIOUS_CLOSE_YIELD", VALUEFUNC(_wrap_YieldType_PREVIOUS_CLOSE_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_AT_ISSUE", VALUEFUNC(_wrap_YieldType_YIELD_AT_ISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_REFUND", VALUEFUNC(_wrap_YieldType_YIELD_TO_NEXT_REFUND_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_AFTER_TAX_YIELD", VALUEFUNC(_wrap_YieldType_AFTER_TAX_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_GVNT_EQUIVALENT_YIELD", VALUEFUNC(_wrap_YieldType_GVNT_EQUIVALENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE", VALUEFUNC(_wrap_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD", VALUEFUNC(_wrap_YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE", VALUEFUNC(_wrap_YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE", VALUEFUNC(_wrap_YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_YEAR", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_CALL", VALUEFUNC(_wrap_YieldType_YIELD_TO_NEXT_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_CHANGE_SINCE_CLOSE", VALUEFUNC(_wrap_YieldType_YIELD_CHANGE_SINCE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PROCEEDS_YIELD", VALUEFUNC(_wrap_YieldType_PROCEEDS_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS", VALUEFUNC(_wrap_YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE", VALUEFUNC(_wrap_YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CURRENT_YIELD", VALUEFUNC(_wrap_YieldType_CURRENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET", VALUEFUNC(_wrap_YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_COMPOUND_YIELD", VALUEFUNC(_wrap_YieldType_COMPOUND_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER", VALUEFUNC(_wrap_YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR", VALUEFUNC(_wrap_YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE", VALUEFUNC(_wrap_YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_AVG_MATURITY", VALUEFUNC(_wrap_YieldType_YIELD_TO_AVG_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO", VALUEFUNC(_wrap_YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_TENDER_DATE", VALUEFUNC(_wrap_YieldType_YIELD_TO_TENDER_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_ANNUAL_YIELD", VALUEFUNC(_wrap_YieldType_ANNUAL_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_WORST", VALUEFUNC(_wrap_YieldType_YIELD_TO_WORST_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_PUT", VALUEFUNC(_wrap_YieldType_YIELD_TO_NEXT_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_BOOK_YIELD", VALUEFUNC(_wrap_YieldType_BOOK_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUE_YIELD", VALUEFUNC(_wrap_YieldType_TRUE_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE", VALUEFUNC(_wrap_YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY", VALUEFUNC(_wrap_YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TAX_EQUIVALENT_YIELD", VALUEFUNC(_wrap_YieldType_TAX_EQUIVALENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO", VALUEFUNC(_wrap_YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE", VALUEFUNC(_wrap_YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUE_GROSS_YIELD", VALUEFUNC(_wrap_YieldType_TRUE_GROSS_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_LONGEST_AVERAGE", VALUEFUNC(_wrap_YieldType_YIELD_TO_LONGEST_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_INVERSE_FLOATER_BOND_YIELD", VALUEFUNC(_wrap_YieldType_INVERSE_FLOATER_BOND_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_MONTH", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS", VALUEFUNC(_wrap_YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_SHORTEST_AVERAGE", VALUEFUNC(_wrap_YieldType_YIELD_TO_SHORTEST_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_OPEN_AVERAGE_YIELD", VALUEFUNC(_wrap_YieldType_OPEN_AVERAGE_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY", VALUEFUNC(_wrap_YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS", VALUEFUNC(_wrap_YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_WITH_INFLATION_ASSUMPTION", VALUEFUNC(_wrap_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE", VALUEFUNC(_wrap_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO", VALUEFUNC(_wrap_YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_AVERAGE_MATURITY", VALUEFUNC(_wrap_YieldType_YIELD_TO_AVERAGE_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS", VALUEFUNC(_wrap_YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE", VALUEFUNC(_wrap_YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SIMPLE_YIELD", VALUEFUNC(_wrap_YieldType_SIMPLE_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE", VALUEFUNC(_wrap_YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SEMI_ANNUAL_YIELD", VALUEFUNC(_wrap_YieldType_SEMI_ANNUAL_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MOST_RECENT_CLOSING_YIELD", VALUEFUNC(_wrap_YieldType_MOST_RECENT_CLOSING_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_GOVERNMENT_EQUIVALENT_YIELD", VALUEFUNC(_wrap_YieldType_GOVERNMENT_EQUIVALENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE", VALUEFUNC(_wrap_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD", VALUEFUNC(_wrap_YieldType_CLOSING_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE", VALUEFUNC(_wrap_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_VALUE_OF_1_32", VALUEFUNC(_wrap_YieldType_YIELD_VALUE_OF_1_32_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE", VALUEFUNC(_wrap_YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE", VALUEFUNC(_wrap_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS", VALUEFUNC(_wrap_YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE", VALUEFUNC(_wrap_YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONAL_XXCLUDING_LOCAL", VALUEFUNC(_wrap_PegScope_NATIONAL_XXCLUDING_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONAL_EXCLUDING_LOCAL", VALUEFUNC(_wrap_PegScope_NATIONAL_EXCLUDING_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_LOCAL", VALUEFUNC(_wrap_PegScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_GLOBAL", VALUEFUNC(_wrap_PegScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONAL", VALUEFUNC(_wrap_PegScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_TRI_PARTY", VALUEFUNC(_wrap_SettlDeliveryType_TRI_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_HOLD_IN_CUSTODY", VALUEFUNC(_wrap_SettlDeliveryType_HOLD_IN_CUSTODY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_FREE", VALUEFUNC(_wrap_SettlDeliveryType_FREE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_VERSUS_PAYMENT_DELIVER", VALUEFUNC(_wrap_SettlDeliveryType_VERSUS_PAYMENT_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_FREE_DELIVER", VALUEFUNC(_wrap_SettlDeliveryType_FREE_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_VERSUS_PAYMENT", VALUEFUNC(_wrap_SettlDeliveryType_VERSUS_PAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_STRICT", VALUEFUNC(_wrap_DiscretionLimitType_STRICT_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_OR_BETTER", VALUEFUNC(_wrap_DiscretionLimitType_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_OR_WORSE", VALUEFUNC(_wrap_DiscretionLimitType_OR_WORSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT", VALUEFUNC(_wrap_DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM", VALUEFUNC(_wrap_DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseMethod_AUTOMATIC", VALUEFUNC(_wrap_ExerciseMethod_AUTOMATIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseMethod_MANUAL", VALUEFUNC(_wrap_ExerciseMethod_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "WorkingIndicator_NO", VALUEFUNC(_wrap_WorkingIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "WorkingIndicator_YES", VALUEFUNC(_wrap_WorkingIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_MULTILEG_SECURITY", VALUEFUNC(_wrap_SideMultiLegReportingType_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_SINGLE_SECURITY", VALUEFUNC(_wrap_SideMultiLegReportingType_SINGLE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_MULTI_LEG_SECURITY", VALUEFUNC(_wrap_SideMultiLegReportingType_MULTI_LEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY", VALUEFUNC(_wrap_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY", VALUEFUNC(_wrap_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS", VALUEFUNC(_wrap_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_OTHER", VALUEFUNC(_wrap_ConfirmRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_MISMATCHED_ACCOUNT", VALUEFUNC(_wrap_ConfirmRejReason_MISMATCHED_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "BidRequestTransType_NEW", VALUEFUNC(_wrap_BidRequestTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "BidRequestTransType_NO", VALUEFUNC(_wrap_BidRequestTransType_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "BidRequestTransType_CANCEL", VALUEFUNC(_wrap_BidRequestTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED", VALUEFUNC(_wrap_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_OTHER", VALUEFUNC(_wrap_MassActionRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT", VALUEFUNC(_wrap_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollApplType_GENERAL", VALUEFUNC(_wrap_CollApplType_GENERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollApplType_SPECIFIC_DEPOSIT", VALUEFUNC(_wrap_CollApplType_SPECIFIC_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_CONFIRMATION", VALUEFUNC(_wrap_ConfirmType_CONFIRMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_CONFIRMATION_REQUEST_REJECTED", VALUEFUNC(_wrap_ConfirmType_CONFIRMATION_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_STATUS", VALUEFUNC(_wrap_ConfirmType_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_INDICATIVE", VALUEFUNC(_wrap_MDQuoteType_INDICATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_RESTRICTED_TRADEABLE", VALUEFUNC(_wrap_MDQuoteType_RESTRICTED_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_INDICATIVE_AND_TRADEABLE", VALUEFUNC(_wrap_MDQuoteType_INDICATIVE_AND_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_TRADEABLE", VALUEFUNC(_wrap_MDQuoteType_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_COUNTER", VALUEFUNC(_wrap_MDQuoteType_COUNTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QtyType_CONTRACTS", VALUEFUNC(_wrap_QtyType_CONTRACTS_get), 0);
  rb_define_singleton_method(mQuickfix, "QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT", VALUEFUNC(_wrap_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QtyType_UNITS", VALUEFUNC(_wrap_QtyType_UNITS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_END_TRADE", VALUEFUNC(_wrap_QuoteRespType_END_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_COVER", VALUEFUNC(_wrap_QuoteRespType_COVER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_HIT_LIFT", VALUEFUNC(_wrap_QuoteRespType_HIT_LIFT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_DONE_AWAY", VALUEFUNC(_wrap_QuoteRespType_DONE_AWAY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_TIMED_OUT", VALUEFUNC(_wrap_QuoteRespType_TIMED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_PASS", VALUEFUNC(_wrap_QuoteRespType_PASS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_EXPIRED", VALUEFUNC(_wrap_QuoteRespType_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_COUNTER", VALUEFUNC(_wrap_QuoteRespType_COUNTER_get), 0);
  rb_define_singleton_method(mQuickfix, "IOINaturalFlag_NO", VALUEFUNC(_wrap_IOINaturalFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "IOINaturalFlag_YES", VALUEFUNC(_wrap_IOINaturalFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligSource_INSTRUCTIONS_OF_BROKER", VALUEFUNC(_wrap_SettlObligSource_INSTRUCTIONS_OF_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligSource_INVESTOR", VALUEFUNC(_wrap_SettlObligSource_INVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION", VALUEFUNC(_wrap_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ON_HOURS_TRADE", VALUEFUNC(_wrap_TrdSubType_ON_HOURS_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_INTERIM_PROTECTED_TRADE", VALUEFUNC(_wrap_TrdSubType_INTERIM_PROTECTED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_K", VALUEFUNC(_wrap_TrdSubType_K_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_LC", VALUEFUNC(_wrap_TrdSubType_LC_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_WN", VALUEFUNC(_wrap_TrdSubType_WN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_CONVERTED_SWAP", VALUEFUNC(_wrap_TrdSubType_CONVERTED_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_B", VALUEFUNC(_wrap_TrdSubType_B_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_M", VALUEFUNC(_wrap_TrdSubType_M_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_RT", VALUEFUNC(_wrap_TrdSubType_RT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ONSET_DUE_TO_AN_ALLOCATION", VALUEFUNC(_wrap_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_CMTA", VALUEFUNC(_wrap_TrdSubType_CMTA_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT", VALUEFUNC(_wrap_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_DIFFERENTIAL_SPREAD", VALUEFUNC(_wrap_TrdSubType_DIFFERENTIAL_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_TRANSACTION_FROM_EXERCISE", VALUEFUNC(_wrap_TrdSubType_TRANSACTION_FROM_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_TRANSACTION_FROM_ASSIGNMENT", VALUEFUNC(_wrap_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_N", VALUEFUNC(_wrap_TrdSubType_N_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT", VALUEFUNC(_wrap_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_NR", VALUEFUNC(_wrap_TrdSubType_NR_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_SW", VALUEFUNC(_wrap_TrdSubType_SW_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_OTC_QUOTE", VALUEFUNC(_wrap_TrdSubType_OTC_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ADVISORY_FOR_CONTRA_SIDE", VALUEFUNC(_wrap_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION", VALUEFUNC(_wrap_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_P", VALUEFUNC(_wrap_TrdSubType_P_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_CROSSED_TRADE", VALUEFUNC(_wrap_TrdSubType_CROSSED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_PA", VALUEFUNC(_wrap_TrdSubType_PA_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT", VALUEFUNC(_wrap_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_R", VALUEFUNC(_wrap_TrdSubType_R_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_RO", VALUEFUNC(_wrap_TrdSubType_RO_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_WT", VALUEFUNC(_wrap_TrdSubType_WT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_OFF_HOURS_TRADE", VALUEFUNC(_wrap_TrdSubType_OFF_HOURS_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_REJECT_FOR_SUBMITTING_SIDE", VALUEFUNC(_wrap_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ONSET_DUT_TO_AN_ALLOCATION", VALUEFUNC(_wrap_TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_AI", VALUEFUNC(_wrap_TrdSubType_AI_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_PC", VALUEFUNC(_wrap_TrdSubType_PC_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_PN", VALUEFUNC(_wrap_TrdSubType_PN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_LARGE_IN_SCALE", VALUEFUNC(_wrap_TrdSubType_LARGE_IN_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_NM", VALUEFUNC(_wrap_TrdSubType_NM_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_T", VALUEFUNC(_wrap_TrdSubType_T_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ACATS", VALUEFUNC(_wrap_TrdSubType_ACATS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_NEW", VALUEFUNC(_wrap_ExecTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_CORRECT", VALUEFUNC(_wrap_ExecTransType_CORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_CANCEL", VALUEFUNC(_wrap_ExecTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_STATUS", VALUEFUNC(_wrap_ExecTransType_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR", VALUEFUNC(_wrap_DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_ACCUMULATE", VALUEFUNC(_wrap_DayBookingInst_ACCUMULATE_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING", VALUEFUNC(_wrap_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_EASTERN_OFF_PEAK", VALUEFUNC(_wrap_FlowScheduleType_NERC_EASTERN_OFF_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_WESTERN_PEAK", VALUEFUNC(_wrap_FlowScheduleType_NERC_WESTERN_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_EASTERN_PEAK", VALUEFUNC(_wrap_FlowScheduleType_NERC_EASTERN_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH", VALUEFUNC(_wrap_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_WESTERN_OFF_PEAK", VALUEFUNC(_wrap_FlowScheduleType_NERC_WESTERN_OFF_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDOriginType_CROSS", VALUEFUNC(_wrap_MDOriginType_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDOriginType_OFF_BOOK", VALUEFUNC(_wrap_MDOriginType_OFF_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDOriginType_BOOK", VALUEFUNC(_wrap_MDOriginType_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_COMPLETED", VALUEFUNC(_wrap_CollInquiryStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_ACCEPTED_WITH_WARNINGS", VALUEFUNC(_wrap_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_REJECTED", VALUEFUNC(_wrap_CollInquiryStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_ACCEPTED", VALUEFUNC(_wrap_CollInquiryStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_COMPLETED_WITH_WARNINGS", VALUEFUNC(_wrap_CollInquiryStatus_COMPLETED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_OTHER", VALUEFUNC(_wrap_CPProgram_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_3", VALUEFUNC(_wrap_CPProgram_3_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_4", VALUEFUNC(_wrap_CPProgram_4_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_POSITIONS", VALUEFUNC(_wrap_PosReqType_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_BACKOUT_MESSAGE", VALUEFUNC(_wrap_PosReqType_BACKOUT_MESSAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_DELTA_POSITIONS", VALUEFUNC(_wrap_PosReqType_DELTA_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_SETTLEMENT_ACTIVITY", VALUEFUNC(_wrap_PosReqType_SETTLEMENT_ACTIVITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_TRADES", VALUEFUNC(_wrap_PosReqType_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_EXERCISES", VALUEFUNC(_wrap_PosReqType_EXERCISES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_ASSIGNMENTS", VALUEFUNC(_wrap_PosReqType_ASSIGNMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_SECURITY_ISSUER", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ALL_ORDERS", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST", VALUEFUNC(_wrap_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES", VALUEFUNC(_wrap_SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_SNAPSHOT", VALUEFUNC(_wrap_SubscriptionRequestType_SNAPSHOT_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_MARKETPLACE_NEWS", VALUEFUNC(_wrap_NewsCategory_MARKETPLACE_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_TECHNICAL_NEWS", VALUEFUNC(_wrap_NewsCategory_TECHNICAL_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_COMPANY_NEWS", VALUEFUNC(_wrap_NewsCategory_COMPANY_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_OTHER_NEWS", VALUEFUNC(_wrap_NewsCategory_OTHER_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_FINANCIAL_MARKET_NEWS", VALUEFUNC(_wrap_NewsCategory_FINANCIAL_MARKET_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_MEDIUM", VALUEFUNC(_wrap_IOIQty_MEDIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_LARGE", VALUEFUNC(_wrap_IOIQty_LARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_SMALL", VALUEFUNC(_wrap_IOIQty_SMALL_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_UNDISCLOSED_QUANTITY", VALUEFUNC(_wrap_IOIQty_UNDISCLOSED_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION", VALUEFUNC(_wrap_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseError_APPLICATION_DOES_NOT_EXIST", VALUEFUNC(_wrap_ApplResponseError_APPLICATION_DOES_NOT_EXIST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE", VALUEFUNC(_wrap_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE", VALUEFUNC(_wrap_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE", VALUEFUNC(_wrap_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_LIQUIDITY_ROUTED_OUT", VALUEFUNC(_wrap_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_AUCTION", VALUEFUNC(_wrap_LastLiquidityInd_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_ADDED_LIQUIDITY", VALUEFUNC(_wrap_LastLiquidityInd_ADDED_LIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_REMOVED_LIQUIDITY", VALUEFUNC(_wrap_LastLiquidityInd_REMOVED_LIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION", VALUEFUNC(_wrap_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE", VALUEFUNC(_wrap_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceDeterminationMethod_FIXED_STRIKE", VALUEFUNC(_wrap_StrikePriceDeterminationMethod_FIXED_STRIKE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE", VALUEFUNC(_wrap_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_PARTICIPATE", VALUEFUNC(_wrap_TargetStrategy_PARTICIPATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_MININIZE_MARKET_IMPACT", VALUEFUNC(_wrap_TargetStrategy_MININIZE_MARKET_IMPACT_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_VWAP", VALUEFUNC(_wrap_TargetStrategy_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "DueToRelated_NO", VALUEFUNC(_wrap_DueToRelated_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "DueToRelated_YES", VALUEFUNC(_wrap_DueToRelated_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingCashType_DIFF", VALUEFUNC(_wrap_UnderlyingCashType_DIFF_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingCashType_FIXED", VALUEFUNC(_wrap_UnderlyingCashType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT", VALUEFUNC(_wrap_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT", VALUEFUNC(_wrap_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER", VALUEFUNC(_wrap_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_ALL_OTHER", VALUEFUNC(_wrap_CustOrderCapacity_ALL_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnershipType_JOINT_TRUSTEES", VALUEFUNC(_wrap_OwnershipType_JOINT_TRUSTEES_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnershipType_JOINT_INVESTORS", VALUEFUNC(_wrap_OwnershipType_JOINT_INVESTORS_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnershipType_TENANTS_IN_COMMON", VALUEFUNC(_wrap_OwnershipType_TENANTS_IN_COMMON_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_US_DOLLARS", VALUEFUNC(_wrap_UnitOfMeasure_US_DOLLARS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_TONS", VALUEFUNC(_wrap_UnitOfMeasure_TONS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_TROY_OUNCES", VALUEFUNC(_wrap_UnitOfMeasure_TROY_OUNCES_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_MEGAWATT_HOURS", VALUEFUNC(_wrap_UnitOfMeasure_MEGAWATT_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_ONE_MILLION_BTU", VALUEFUNC(_wrap_UnitOfMeasure_ONE_MILLION_BTU_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_BILLION_CUBIC_FEET", VALUEFUNC(_wrap_UnitOfMeasure_BILLION_CUBIC_FEET_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_MILLION_BARRELS", VALUEFUNC(_wrap_UnitOfMeasure_MILLION_BARRELS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_GALLONS", VALUEFUNC(_wrap_UnitOfMeasure_GALLONS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_BARRELS", VALUEFUNC(_wrap_UnitOfMeasure_BARRELS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_POUNDS", VALUEFUNC(_wrap_UnitOfMeasure_POUNDS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_METRIC_TONS", VALUEFUNC(_wrap_UnitOfMeasure_METRIC_TONS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_ALLOWANCES", VALUEFUNC(_wrap_UnitOfMeasure_ALLOWANCES_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_BUSHELS", VALUEFUNC(_wrap_UnitOfMeasure_BUSHELS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_WHEN_AND_IF_ISSUED", VALUEFUNC(_wrap_SettlmntTyp_WHEN_AND_IF_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_1", VALUEFUNC(_wrap_SettlmntTyp_T_PLUS_1_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_FUTURE", VALUEFUNC(_wrap_SettlmntTyp_FUTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_SELLERS_OPTION", VALUEFUNC(_wrap_SettlmntTyp_SELLERS_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_2", VALUEFUNC(_wrap_SettlmntTyp_T_PLUS_2_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_3", VALUEFUNC(_wrap_SettlmntTyp_T_PLUS_3_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_4", VALUEFUNC(_wrap_SettlmntTyp_T_PLUS_4_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_REGULAR", VALUEFUNC(_wrap_SettlmntTyp_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_5", VALUEFUNC(_wrap_SettlmntTyp_T_PLUS_5_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_WHEN_ISSUED", VALUEFUNC(_wrap_SettlmntTyp_WHEN_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_NEXT_DAY", VALUEFUNC(_wrap_SettlmntTyp_NEXT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_CASH", VALUEFUNC(_wrap_SettlmntTyp_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradePublishIndicator_DO_NOT_PUBLISH_TRADE", VALUEFUNC(_wrap_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradePublishIndicator_DEFERRED_PUBLICATION", VALUEFUNC(_wrap_TradePublishIndicator_DEFERRED_PUBLICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradePublishIndicator_PUBLISH_TRADE", VALUEFUNC(_wrap_TradePublishIndicator_PUBLISH_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseType_MESSAGES_NOT_AVAILABLE", VALUEFUNC(_wrap_ApplResponseType_MESSAGES_NOT_AVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseType_APPLICATION_DOES_NOT_EXIST", VALUEFUNC(_wrap_ApplResponseType_APPLICATION_DOES_NOT_EXIST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED", VALUEFUNC(_wrap_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_DTC_SID", VALUEFUNC(_wrap_StandInstDbType_DTC_SID_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_ACCOUNTNET", VALUEFUNC(_wrap_StandInstDbType_ACCOUNTNET_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_A_GLOBAL_CUSTODIAN", VALUEFUNC(_wrap_StandInstDbType_A_GLOBAL_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_THOMSON_ALERT", VALUEFUNC(_wrap_StandInstDbType_THOMSON_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_OTHER", VALUEFUNC(_wrap_StandInstDbType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_CROSS_MARKET_WARNING", VALUEFUNC(_wrap_QuoteEntryStatus_CROSS_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_LOCKED_MARKET_WARNING", VALUEFUNC(_wrap_QuoteEntryStatus_LOCKED_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET", VALUEFUNC(_wrap_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET", VALUEFUNC(_wrap_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_REJECTED", VALUEFUNC(_wrap_QuoteEntryStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_EXPIRED", VALUEFUNC(_wrap_QuoteEntryStatus_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_REMOVED_FROM_MARKET", VALUEFUNC(_wrap_QuoteEntryStatus_REMOVED_FROM_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_ACCEPTED", VALUEFUNC(_wrap_QuoteEntryStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_ACTIVE", VALUEFUNC(_wrap_QuoteEntryStatus_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_MID", VALUEFUNC(_wrap_TriggerPriceType_BEST_MID_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_BID_OR_LAST_TRADE", VALUEFUNC(_wrap_TriggerPriceType_BEST_BID_OR_LAST_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_BID", VALUEFUNC(_wrap_TriggerPriceType_BEST_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_OFFER_OR_LAST_TRADE", VALUEFUNC(_wrap_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_OFFER", VALUEFUNC(_wrap_TriggerPriceType_BEST_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_LAST_TRADE", VALUEFUNC(_wrap_TriggerPriceType_LAST_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST", VALUEFUNC(_wrap_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND", VALUEFUNC(_wrap_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_UNKNOWN_ACCOUNT", VALUEFUNC(_wrap_SettlInstReqRejCode_UNKNOWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_OTHER", VALUEFUNC(_wrap_SettlInstReqRejCode_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "Urgency_FLASH", VALUEFUNC(_wrap_Urgency_FLASH_get), 0);
  rb_define_singleton_method(mQuickfix, "Urgency_NORMAL", VALUEFUNC(_wrap_Urgency_NORMAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Urgency_BACKGROUND", VALUEFUNC(_wrap_Urgency_BACKGROUND_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_REPLACE", VALUEFUNC(_wrap_CollAsgnTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_NEW", VALUEFUNC(_wrap_CollAsgnTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_REVERSE", VALUEFUNC(_wrap_CollAsgnTransType_REVERSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_CANCEL", VALUEFUNC(_wrap_CollAsgnTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_RELEASE", VALUEFUNC(_wrap_CollAsgnTransType_RELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_FED_WIRE", VALUEFUNC(_wrap_PaymentMethod_FED_WIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_EUROCLEAR", VALUEFUNC(_wrap_PaymentMethod_EUROCLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_ACH_CREDIT", VALUEFUNC(_wrap_PaymentMethod_ACH_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_TELEGRAPHIC_TRANSFER", VALUEFUNC(_wrap_PaymentMethod_TELEGRAPHIC_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_FEDWIRE", VALUEFUNC(_wrap_PaymentMethod_FEDWIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DIRECT_DEBIT", VALUEFUNC(_wrap_PaymentMethod_DIRECT_DEBIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CREDIT_CARD", VALUEFUNC(_wrap_PaymentMethod_CREDIT_CARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CHEQUE", VALUEFUNC(_wrap_PaymentMethod_CHEQUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DIRECT_CREDIT", VALUEFUNC(_wrap_PaymentMethod_DIRECT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CREST", VALUEFUNC(_wrap_PaymentMethod_CREST_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM", VALUEFUNC(_wrap_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CLEARSTREAM", VALUEFUNC(_wrap_PaymentMethod_CLEARSTREAM_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_BPAY", VALUEFUNC(_wrap_PaymentMethod_BPAY_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_NSCC", VALUEFUNC(_wrap_PaymentMethod_NSCC_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DEBIT_CARD", VALUEFUNC(_wrap_PaymentMethod_DEBIT_CARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_ACH_DEBIT", VALUEFUNC(_wrap_PaymentMethod_ACH_DEBIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_LOCAL", VALUEFUNC(_wrap_TriggerPriceTypeScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_NONE", VALUEFUNC(_wrap_TriggerPriceTypeScope_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_GLOBAL", VALUEFUNC(_wrap_TriggerPriceTypeScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_NATIONAL", VALUEFUNC(_wrap_TriggerPriceTypeScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_STRICT", VALUEFUNC(_wrap_PegLimitType_STRICT_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_OR_BETTER", VALUEFUNC(_wrap_PegLimitType_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_OR_WORSE", VALUEFUNC(_wrap_PegLimitType_OR_WORSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT", VALUEFUNC(_wrap_PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM", VALUEFUNC(_wrap_PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BORROW", VALUEFUNC(_wrap_Side_BORROW_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BUY_MINUS", VALUEFUNC(_wrap_Side_BUY_MINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SUBSCRIBE", VALUEFUNC(_wrap_Side_SUBSCRIBE_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS_SHORT_EXEMPT", VALUEFUNC(_wrap_Side_CROSS_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_UNDISCLOSED", VALUEFUNC(_wrap_Side_UNDISCLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS", VALUEFUNC(_wrap_Side_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL_SHORT_EXEMPT", VALUEFUNC(_wrap_Side_SELL_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BUY", VALUEFUNC(_wrap_Side_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS_SHORT_EXXMPT", VALUEFUNC(_wrap_Side_CROSS_SHORT_EXXMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL", VALUEFUNC(_wrap_Side_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_LEND", VALUEFUNC(_wrap_Side_LEND_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL_SHORT", VALUEFUNC(_wrap_Side_SELL_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_OPPOSITE", VALUEFUNC(_wrap_Side_OPPOSITE_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS_SHORT", VALUEFUNC(_wrap_Side_CROSS_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL_PLUS", VALUEFUNC(_wrap_Side_SELL_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_REDEEM", VALUEFUNC(_wrap_Side_REDEEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_AS_DEFINED", VALUEFUNC(_wrap_Side_AS_DEFINED_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXIT_CHARGE", VALUEFUNC(_wrap_ContAmtType_EXIT_CHARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTION_LEVY_AMOUNT", VALUEFUNC(_wrap_ContAmtType_DILUTION_LEVY_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTION_LEVY_PERCENT", VALUEFUNC(_wrap_ContAmtType_DILUTION_LEVY_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNT_AMOUNT", VALUEFUNC(_wrap_ContAmtType_DISCOUNT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSION", VALUEFUNC(_wrap_ContAmtType_COMMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIAL_CHARGE_PERCENT", VALUEFUNC(_wrap_ContAmtType_INITIAL_CHARGE_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTION_LEVY", VALUEFUNC(_wrap_ContAmtType_DILUTION_LEVY_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSION_AMOUNT", VALUEFUNC(_wrap_ContAmtType_COMMISSION_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_NET_SETTLEMENT_AMOUNT", VALUEFUNC(_wrap_ContAmtType_NET_SETTLEMENT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION", VALUEFUNC(_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNT", VALUEFUNC(_wrap_ContAmtType_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13", VALUEFUNC(_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXIT_CHARGE_AMOUNT", VALUEFUNC(_wrap_ContAmtType_EXIT_CHARGE_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIAL_CHARGE", VALUEFUNC(_wrap_ContAmtType_INITIAL_CHARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNT_PERCENT", VALUEFUNC(_wrap_ContAmtType_DISCOUNT_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXIT_CHARGE_PERCENT", VALUEFUNC(_wrap_ContAmtType_EXIT_CHARGE_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14", VALUEFUNC(_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSION_PERCENT", VALUEFUNC(_wrap_ContAmtType_COMMISSION_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT", VALUEFUNC(_wrap_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_PROJECTED_FUND_VALUE", VALUEFUNC(_wrap_ContAmtType_PROJECTED_FUND_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIAL_CHARGE_AMOUNT", VALUEFUNC(_wrap_ContAmtType_INITIAL_CHARGE_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_IMPLIED_ORDER", VALUEFUNC(_wrap_OrderCategory_IMPLIED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_STREAMING_PRICE", VALUEFUNC(_wrap_OrderCategory_STREAMING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_QUOTE_REQUEST", VALUEFUNC(_wrap_OrderCategory_QUOTE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_CROSS_ORDER", VALUEFUNC(_wrap_OrderCategory_CROSS_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_MULTILEG_ORDER", VALUEFUNC(_wrap_OrderCategory_MULTILEG_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_PRIVATELY_NEGOTIATED_TRADE", VALUEFUNC(_wrap_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_QUOTE", VALUEFUNC(_wrap_OrderCategory_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_ORDER", VALUEFUNC(_wrap_OrderCategory_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_LINKED_ORDER", VALUEFUNC(_wrap_OrderCategory_LINKED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_REPLACE", VALUEFUNC(_wrap_AdvTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_NEW", VALUEFUNC(_wrap_AdvTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_CANCEL", VALUEFUNC(_wrap_AdvTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PublishTrdIndicator_NO", VALUEFUNC(_wrap_PublishTrdIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PublishTrdIndicator_YES", VALUEFUNC(_wrap_PublishTrdIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST", VALUEFUNC(_wrap_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST", VALUEFUNC(_wrap_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE", VALUEFUNC(_wrap_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS", VALUEFUNC(_wrap_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_REJECT_SECURITY_PROPOSAL", VALUEFUNC(_wrap_SecurityResponseType_REJECT_SECURITY_PROPOSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA", VALUEFUNC(_wrap_SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA", VALUEFUNC(_wrap_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_PASSWORD_EXPIRED", VALUEFUNC(_wrap_SessionStatus_PASSWORD_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_LOGOUT_COMPLETE", VALUEFUNC(_wrap_SessionStatus_SESSION_LOGOUT_COMPLETE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_INVALID_USERNAME_OR_PASSWORD", VALUEFUNC(_wrap_SessionStatus_INVALID_USERNAME_OR_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_ACTIVE", VALUEFUNC(_wrap_SessionStatus_SESSION_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_PASSWORD_CHANGED", VALUEFUNC(_wrap_SessionStatus_SESSION_PASSWORD_CHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_ACCOUNT_LOCKED", VALUEFUNC(_wrap_SessionStatus_ACCOUNT_LOCKED_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME", VALUEFUNC(_wrap_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE", VALUEFUNC(_wrap_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY", VALUEFUNC(_wrap_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_HOUSE_TRADER", VALUEFUNC(_wrap_AllocAccountType_HOUSE_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_FLOOR_TRADER", VALUEFUNC(_wrap_AllocAccountType_FLOOR_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT", VALUEFUNC(_wrap_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED", VALUEFUNC(_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(_wrap_AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_JOINT_BACKOFFICE_ACCOUNT", VALUEFUNC(_wrap_AllocAccountType_JOINT_BACKOFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED", VALUEFUNC(_wrap_AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_REPLACE", VALUEFUNC(_wrap_AllocTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_NEW", VALUEFUNC(_wrap_AllocTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CALCULATED", VALUEFUNC(_wrap_AllocTransType_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_PRELIMINARY", VALUEFUNC(_wrap_AllocTransType_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CANCEL", VALUEFUNC(_wrap_AllocTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_REVERSAL", VALUEFUNC(_wrap_AllocTransType_REVERSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CALCULATED_WITHOUT_PRELIMINARY", VALUEFUNC(_wrap_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_DIFFERENCE", VALUEFUNC(_wrap_ExpirationQtyType_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_FINAL_WILL_BE_EXERCISED", VALUEFUNC(_wrap_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_NON_AUTO_EXERCISE", VALUEFUNC(_wrap_ExpirationQtyType_NON_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_CONTRARY_INTENTION", VALUEFUNC(_wrap_ExpirationQtyType_CONTRARY_INTENTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_AUTO_EXERCISE", VALUEFUNC(_wrap_ExpirationQtyType_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_FORWARD_AND_MATCH", VALUEFUNC(_wrap_AllocHandlInst_FORWARD_AND_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_FORWARD", VALUEFUNC(_wrap_AllocHandlInst_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_MATCH", VALUEFUNC(_wrap_AllocHandlInst_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestStatus_COMPLETED", VALUEFUNC(_wrap_TradeRequestStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestStatus_REJECTED", VALUEFUNC(_wrap_TradeRequestStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestStatus_ACCEPTED", VALUEFUNC(_wrap_TradeRequestStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST", VALUEFUNC(_wrap_PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_PRO_RATA", VALUEFUNC(_wrap_PreallocMethod_PRO_RATA_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_DO_NOT_PRO_RATA", VALUEFUNC(_wrap_PreallocMethod_DO_NOT_PRO_RATA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_457", VALUEFUNC(_wrap_TaxAdvantageType_457_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MAXI_ISA", VALUEFUNC(_wrap_TaxAdvantageType_MAXI_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE_CURRENT_YEAR", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE_9", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYEE_9_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_403", VALUEFUNC(_wrap_TaxAdvantageType_403_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_KEOGH", VALUEFUNC(_wrap_TaxAdvantageType_KEOGH_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_401K", VALUEFUNC(_wrap_TaxAdvantageType_401K_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_SELF_DIRECTED_IRA", VALUEFUNC(_wrap_TaxAdvantageType_SELF_DIRECTED_IRA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN", VALUEFUNC(_wrap_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16", VALUEFUNC(_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_IRA_24", VALUEFUNC(_wrap_TaxAdvantageType_ROTH_IRA_24_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_CURRENT_YEAR_PAYMENT", VALUEFUNC(_wrap_TaxAdvantageType_CURRENT_YEAR_PAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINI_INSURANCE_ISA", VALUEFUNC(_wrap_TaxAdvantageType_MINI_INSURANCE_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17", VALUEFUNC(_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EDUCATION_IRA_28", VALUEFUNC(_wrap_TaxAdvantageType_EDUCATION_IRA_28_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_IRA_25", VALUEFUNC(_wrap_TaxAdvantageType_ROTH_IRA_25_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT", VALUEFUNC(_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE_10", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYEE_10_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EDUCATION_IRA_29", VALUEFUNC(_wrap_TaxAdvantageType_EDUCATION_IRA_29_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_PRIOR_YEAR_PAYMENT", VALUEFUNC(_wrap_TaxAdvantageType_PRIOR_YEAR_PAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER", VALUEFUNC(_wrap_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER_11", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYER_11_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ASSET_TRANSFER", VALUEFUNC(_wrap_TaxAdvantageType_ASSET_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER_12", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYER_12_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_OTHER", VALUEFUNC(_wrap_TaxAdvantageType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA", VALUEFUNC(_wrap_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYEE_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_CONVERSION_IRA_26", VALUEFUNC(_wrap_TaxAdvantageType_ROTH_CONVERSION_IRA_26_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINI_CASH_ISA", VALUEFUNC(_wrap_TaxAdvantageType_MINI_CASH_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_CONVERSION_IRA_27", VALUEFUNC(_wrap_TaxAdvantageType_ROTH_CONVERSION_IRA_27_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NONE_NOT_APPLICABLE", VALUEFUNC(_wrap_TaxAdvantageType_NONE_NOT_APPLICABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_TESSA", VALUEFUNC(_wrap_TaxAdvantageType_TESSA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NON_FUND_QUALIFIED_PLAN", VALUEFUNC(_wrap_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER_CURRENT_YEAR", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER", VALUEFUNC(_wrap_TaxAdvantageType_EMPLOYER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_PROFIT_SHARING_PLAN", VALUEFUNC(_wrap_TaxAdvantageType_PROFIT_SHARING_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_401", VALUEFUNC(_wrap_TaxAdvantageType_401_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NON_FUND_PROTOTYPE_IRA", VALUEFUNC(_wrap_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_EUC_JP", VALUEFUNC(_wrap_MessageEncoding_EUC_JP_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_SHIFT_JIS", VALUEFUNC(_wrap_MessageEncoding_SHIFT_JIS_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_UTF_8", VALUEFUNC(_wrap_MessageEncoding_UTF_8_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_ISO_2022_JP", VALUEFUNC(_wrap_MessageEncoding_ISO_2022_JP_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_EUC", VALUEFUNC(_wrap_MessageEncoding_EUC_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_JIS", VALUEFUNC(_wrap_MessageEncoding_JIS_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_FOR_USING_SJIS", VALUEFUNC(_wrap_MessageEncoding_FOR_USING_SJIS_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_UNICODE", VALUEFUNC(_wrap_MessageEncoding_UNICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_TILL_CROSSING", VALUEFUNC(_wrap_TimeInForce_GOOD_TILL_CROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_FILL_OR_KILL", VALUEFUNC(_wrap_TimeInForce_FILL_OR_KILL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_TILL_DATE", VALUEFUNC(_wrap_TimeInForce_GOOD_TILL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_TILL_CANCEL", VALUEFUNC(_wrap_TimeInForce_GOOD_TILL_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_DAY", VALUEFUNC(_wrap_TimeInForce_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_AT_CROSSING", VALUEFUNC(_wrap_TimeInForce_AT_CROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_IMMEDIATE_OR_CANCEL", VALUEFUNC(_wrap_TimeInForce_IMMEDIATE_OR_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_THROUGH_CROSSING", VALUEFUNC(_wrap_TimeInForce_GOOD_THROUGH_CROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_AT_THE_CLOSE", VALUEFUNC(_wrap_TimeInForce_AT_THE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_AT_THE_OPENING", VALUEFUNC(_wrap_TimeInForce_AT_THE_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_THROUGH_THE_DAY", VALUEFUNC(_wrap_IOIQualifier_THROUGH_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_INDIDCATION", VALUEFUNC(_wrap_IOIQualifier_INDIDCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_MARKET", VALUEFUNC(_wrap_IOIQualifier_AT_THE_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_MIDPOINT", VALUEFUNC(_wrap_IOIQualifier_AT_THE_MIDPOINT_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_CROSSING_OPPORTUNITY", VALUEFUNC(_wrap_IOIQualifier_CROSSING_OPPORTUNITY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_CURRENT_QUOTE", VALUEFUNC(_wrap_IOIQualifier_CURRENT_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_IN_TOUCH_WITH", VALUEFUNC(_wrap_IOIQualifier_IN_TOUCH_WITH_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_ALL_OR_NONE", VALUEFUNC(_wrap_IOIQualifier_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_TAKING_A_POSITION", VALUEFUNC(_wrap_IOIQualifier_TAKING_A_POSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_OPEN", VALUEFUNC(_wrap_IOIQualifier_AT_THE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PORTFOLIO_SHOW_N", VALUEFUNC(_wrap_IOIQualifier_PORTFOLIO_SHOW_N_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_MARKET_ON_CLOSE", VALUEFUNC(_wrap_IOIQualifier_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_VERSUS", VALUEFUNC(_wrap_IOIQualifier_VERSUS_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_LIMIT", VALUEFUNC(_wrap_IOIQualifier_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PORTFOLIO_SHOWN", VALUEFUNC(_wrap_IOIQualifier_PORTFOLIO_SHOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_READY_TO_TRADE", VALUEFUNC(_wrap_IOIQualifier_READY_TO_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PRE_OPEN", VALUEFUNC(_wrap_IOIQualifier_PRE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_INDICATION", VALUEFUNC(_wrap_IOIQualifier_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_MORE_BEHIND", VALUEFUNC(_wrap_IOIQualifier_MORE_BEHIND_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_VWAP", VALUEFUNC(_wrap_IOIQualifier_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_CLOSE", VALUEFUNC(_wrap_IOIQualifier_AT_THE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY", VALUEFUNC(_wrap_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY", VALUEFUNC(_wrap_StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY", VALUEFUNC(_wrap_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY", VALUEFUNC(_wrap_StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY", VALUEFUNC(_wrap_StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_CONVERSION", VALUEFUNC(_wrap_MiscFeeType_CONVERSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_CONSUMPTION_TAX", VALUEFUNC(_wrap_MiscFeeType_CONSUMPTION_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_LOCAL_COMMISSION", VALUEFUNC(_wrap_MiscFeeType_LOCAL_COMMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_TAX", VALUEFUNC(_wrap_MiscFeeType_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_MARKUP", VALUEFUNC(_wrap_MiscFeeType_MARKUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_SECURITY_LENDING", VALUEFUNC(_wrap_MiscFeeType_SECURITY_LENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_PER_TRANSACTION", VALUEFUNC(_wrap_MiscFeeType_PER_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_REGULATORY", VALUEFUNC(_wrap_MiscFeeType_REGULATORY_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_STAMP", VALUEFUNC(_wrap_MiscFeeType_STAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_TRANSFER_FEE", VALUEFUNC(_wrap_MiscFeeType_TRANSFER_FEE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_AGENT", VALUEFUNC(_wrap_MiscFeeType_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_OTHER", VALUEFUNC(_wrap_MiscFeeType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_EXCHANGE_FEES", VALUEFUNC(_wrap_MiscFeeType_EXCHANGE_FEES_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_LEVY", VALUEFUNC(_wrap_MiscFeeType_LEVY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY", VALUEFUNC(_wrap_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CLEARING_HOUSE", VALUEFUNC(_wrap_SecurityIDSource_CLEARING_HOUSE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_EXCHANGE_SYMBOL", VALUEFUNC(_wrap_SecurityIDSource_EXCHANGE_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_SICOVAM", VALUEFUNC(_wrap_SecurityIDSource_SICOVAM_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISDA_FPML_PRODUCT_URL", VALUEFUNC(_wrap_SecurityIDSource_ISDA_FPML_PRODUCT_URL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION", VALUEFUNC(_wrap_SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_RIC_CODE", VALUEFUNC(_wrap_SecurityIDSource_RIC_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISO_CURRENCY_CODE", VALUEFUNC(_wrap_SecurityIDSource_ISO_CURRENCY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_COMMON", VALUEFUNC(_wrap_SecurityIDSource_COMMON_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_VALOREN", VALUEFUNC(_wrap_SecurityIDSource_VALOREN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_BELGIAN", VALUEFUNC(_wrap_SecurityIDSource_BELGIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY", VALUEFUNC(_wrap_SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISIN_NUMBER", VALUEFUNC(_wrap_SecurityIDSource_ISIN_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_SEDOL", VALUEFUNC(_wrap_SecurityIDSource_SEDOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISO_COUNTRY_CODE", VALUEFUNC(_wrap_SecurityIDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_LETTER_OF_CREDIT", VALUEFUNC(_wrap_SecurityIDSource_LETTER_OF_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_BLOOMBERG_SYMBOL", VALUEFUNC(_wrap_SecurityIDSource_BLOOMBERG_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_WERTPAPIER", VALUEFUNC(_wrap_SecurityIDSource_WERTPAPIER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER", VALUEFUNC(_wrap_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION", VALUEFUNC(_wrap_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_DUTCH", VALUEFUNC(_wrap_SecurityIDSource_DUTCH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_QUIK", VALUEFUNC(_wrap_SecurityIDSource_QUIK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CUSIP", VALUEFUNC(_wrap_SecurityIDSource_CUSIP_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsRefType_OTHER_LANGUAGE", VALUEFUNC(_wrap_NewsRefType_OTHER_LANGUAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsRefType_COMPLIMENTARY", VALUEFUNC(_wrap_NewsRefType_COMPLIMENTARY_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsRefType_REPLACEMENT", VALUEFUNC(_wrap_NewsRefType_REPLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerOrderType_LIMIT", VALUEFUNC(_wrap_TriggerOrderType_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerOrderType_MARKET", VALUEFUNC(_wrap_TriggerOrderType_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES", VALUEFUNC(_wrap_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_AON", VALUEFUNC(_wrap_CrossType_CROSS_AON_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED", VALUEFUNC(_wrap_CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE", VALUEFUNC(_wrap_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE", VALUEFUNC(_wrap_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_ONE_SIDE", VALUEFUNC(_wrap_CrossType_CROSS_ONE_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_SAME_PRICE", VALUEFUNC(_wrap_CrossType_CROSS_SAME_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_IOC", VALUEFUNC(_wrap_CrossType_CROSS_IOC_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE", VALUEFUNC(_wrap_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION", VALUEFUNC(_wrap_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_SESSION_OPEN", VALUEFUNC(_wrap_OpenCloseSettleFlag_SESSION_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_DAILY_OPEN", VALUEFUNC(_wrap_OpenCloseSettleFlag_DAILY_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_EXPECTED_PRICE", VALUEFUNC(_wrap_OpenCloseSettleFlag_EXPECTED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY", VALUEFUNC(_wrap_OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE", VALUEFUNC(_wrap_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDBookType_PRICE_DEPTH", VALUEFUNC(_wrap_MDBookType_PRICE_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDBookType_ORDER_DEPTH", VALUEFUNC(_wrap_MDBookType_ORDER_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDBookType_TOP_OF_BOOK", VALUEFUNC(_wrap_MDBookType_TOP_OF_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI", VALUEFUNC(_wrap_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_MORNING_SESSION", VALUEFUNC(_wrap_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLOSING_PRICE", VALUEFUNC(_wrap_BasisPxType_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_DAY", VALUEFUNC(_wrap_BasisPxType_VWAP_THROUGH_A_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_OTHERS", VALUEFUNC(_wrap_BasisPxType_OTHERS_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_OPEN", VALUEFUNC(_wrap_BasisPxType_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION", VALUEFUNC(_wrap_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CURRENT_PRICE", VALUEFUNC(_wrap_BasisPxType_CURRENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_SQ", VALUEFUNC(_wrap_BasisPxType_SQ_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_STRIKE", VALUEFUNC(_wrap_BasisPxType_STRIKE_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI", VALUEFUNC(_wrap_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI", VALUEFUNC(_wrap_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION", VALUEFUNC(_wrap_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_ROLLING_BARRIER", VALUEFUNC(_wrap_ComplexEventType_ROLLING_BARRIER_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_UNDERLYING", VALUEFUNC(_wrap_ComplexEventType_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KNOCK_OUT_UP", VALUEFUNC(_wrap_ComplexEventType_KNOCK_OUT_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KNOCK_IN_UP", VALUEFUNC(_wrap_ComplexEventType_KNOCK_IN_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KOCK_IN_DOWN", VALUEFUNC(_wrap_ComplexEventType_KOCK_IN_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_TRIGGER", VALUEFUNC(_wrap_ComplexEventType_TRIGGER_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_RESET_BARRIER", VALUEFUNC(_wrap_ComplexEventType_RESET_BARRIER_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_CAPPED", VALUEFUNC(_wrap_ComplexEventType_CAPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KNOCK_OUT_DOWN", VALUEFUNC(_wrap_ComplexEventType_KNOCK_OUT_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionResponse_REJECTED", VALUEFUNC(_wrap_MassActionResponse_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionResponse_ACCEPTED", VALUEFUNC(_wrap_MassActionResponse_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID", VALUEFUNC(_wrap_SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_LIST_SECURITY_TYPES", VALUEFUNC(_wrap_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_LIST_SECURITIES", VALUEFUNC(_wrap_SecurityRequestType_REQUEST_LIST_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_SYMBOL", VALUEFUNC(_wrap_SecurityRequestType_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE", VALUEFUNC(_wrap_SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED", VALUEFUNC(_wrap_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_TRADINGSESSIONID", VALUEFUNC(_wrap_SecurityRequestType_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_PRODUCT", VALUEFUNC(_wrap_SecurityRequestType_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_ALL_SECURITIES", VALUEFUNC(_wrap_SecurityRequestType_ALL_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS", VALUEFUNC(_wrap_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_EXCHANGE_CLOSED", VALUEFUNC(_wrap_ListRejectReason_EXCHANGE_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_UNKNOWN_ORDER", VALUEFUNC(_wrap_ListRejectReason_UNKNOWN_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC", VALUEFUNC(_wrap_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_DUPLICATE_ORDER", VALUEFUNC(_wrap_ListRejectReason_DUPLICATE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(_wrap_ListRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_OTHER", VALUEFUNC(_wrap_ListRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_BROKER", VALUEFUNC(_wrap_ListRejectReason_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_PROPRIETARY", VALUEFUNC(_wrap_DeskType_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_ARBITRAGE", VALUEFUNC(_wrap_DeskType_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_TRADING", VALUEFUNC(_wrap_DeskType_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_DERIVATIVES", VALUEFUNC(_wrap_DeskType_DERIVATIVES_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_SALES", VALUEFUNC(_wrap_DeskType_SALES_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_INSTITUTIONAL", VALUEFUNC(_wrap_DeskType_INSTITUTIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_INTERNATIONAL", VALUEFUNC(_wrap_DeskType_INTERNATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_AGENCY", VALUEFUNC(_wrap_DeskType_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_PREFERRED_TRADING", VALUEFUNC(_wrap_DeskType_PREFERRED_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_OTHER", VALUEFUNC(_wrap_DeskType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_PROGRAM_TRADING", VALUEFUNC(_wrap_DeskType_PROGRAM_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_WHEN_AND_IF_ISSUED", VALUEFUNC(_wrap_SettlType_WHEN_AND_IF_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_FUTURE", VALUEFUNC(_wrap_SettlType_FUTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_BROKEN_DATE", VALUEFUNC(_wrap_SettlType_BROKEN_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_SELLERS_OPTION", VALUEFUNC(_wrap_SettlType_SELLERS_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_2", VALUEFUNC(_wrap_SettlType_T_PLUS_2_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_3", VALUEFUNC(_wrap_SettlType_T_PLUS_3_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_4", VALUEFUNC(_wrap_SettlType_T_PLUS_4_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_REGULAR", VALUEFUNC(_wrap_SettlType_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_FX_SPOT_NEXT_SETTLEMENT", VALUEFUNC(_wrap_SettlType_FX_SPOT_NEXT_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_5", VALUEFUNC(_wrap_SettlType_T_PLUS_5_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_NEXT_DAY", VALUEFUNC(_wrap_SettlType_NEXT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_CASH", VALUEFUNC(_wrap_SettlType_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenClose_CLOSE", VALUEFUNC(_wrap_OpenClose_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenClose_OPEN", VALUEFUNC(_wrap_OpenClose_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ContractMultiplierUnit_SHARES", VALUEFUNC(_wrap_ContractMultiplierUnit_SHARES_get), 0);
  rb_define_singleton_method(mQuickfix, "ContractMultiplierUnit_HOURS", VALUEFUNC(_wrap_ContractMultiplierUnit_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "ContractMultiplierUnit_DAYS", VALUEFUNC(_wrap_ContractMultiplierUnit_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE", VALUEFUNC(_wrap_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_FUTURES_LARGE_ORDER_EXECUTION", VALUEFUNC(_wrap_TrdType_FUTURES_LARGE_ORDER_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES", VALUEFUNC(_wrap_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS", VALUEFUNC(_wrap_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADE_38", VALUEFUNC(_wrap_TrdType_BLOCK_TRADE_38_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_DELTA_NEUTRAL_TRANSACTION", VALUEFUNC(_wrap_TrdType_DELTA_NEUTRAL_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_LATE_TRADE", VALUEFUNC(_wrap_TrdType_LATE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_CASH_SETTLEMENT", VALUEFUNC(_wrap_TrdType_CASH_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS", VALUEFUNC(_wrap_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_BONUS", VALUEFUNC(_wrap_TrdType_SPECIAL_CUM_BONUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADES", VALUEFUNC(_wrap_TrdType_BLOCK_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_ALL_OR_NONE", VALUEFUNC(_wrap_TrdType_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OPTION_EXERCISE", VALUEFUNC(_wrap_TrdType_OPTION_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_FINANCING_TRANSACTION", VALUEFUNC(_wrap_TrdType_FINANCING_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_TRANSFER", VALUEFUNC(_wrap_TrdType_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_TRADING_AT_SETTLEMENT", VALUEFUNC(_wrap_TrdType_TRADING_AT_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_DIVIDEND", VALUEFUNC(_wrap_TrdType_SPECIAL_EX_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_COUPON", VALUEFUNC(_wrap_TrdType_SPECIAL_EX_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_PRICE", VALUEFUNC(_wrap_TrdType_SPECIAL_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_RIGHTS", VALUEFUNC(_wrap_TrdType_SPECIAL_CUM_RIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_BONUS", VALUEFUNC(_wrap_TrdType_SPECIAL_EX_BONUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_REGULAR_TRADE", VALUEFUNC(_wrap_TrdType_REGULAR_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_GRANTED_TRADE", VALUEFUNC(_wrap_TrdType_EXCHANGE_GRANTED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_BASIS_FACILITY", VALUEFUNC(_wrap_TrdType_EXCHANGE_BASIS_FACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADE_1", VALUEFUNC(_wrap_TrdType_BLOCK_TRADE_1_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_ERROR_TRADE", VALUEFUNC(_wrap_TrdType_ERROR_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_NAME_CHANGE", VALUEFUNC(_wrap_TrdType_NAME_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_LATE_BUNCHED_TRADE", VALUEFUNC(_wrap_TrdType_LATE_BUNCHED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EFP", VALUEFUNC(_wrap_TrdType_EFP_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_NON_STANDARD_SETTLEMENT", VALUEFUNC(_wrap_TrdType_NON_STANDARD_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_FOR_RISK", VALUEFUNC(_wrap_TrdType_EXCHANGE_FOR_RISK_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_FOR_SWAP", VALUEFUNC(_wrap_TrdType_EXCHANGE_FOR_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_OF_FUTURES_FOR", VALUEFUNC(_wrap_TrdType_EXCHANGE_OF_FUTURES_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OPTION_INTERIM_TRADE", VALUEFUNC(_wrap_TrdType_OPTION_INTERIM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PRIVATELY_NEGOTIATED_TRADES", VALUEFUNC(_wrap_TrdType_PRIVATELY_NEGOTIATED_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS", VALUEFUNC(_wrap_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_DIVIDEND", VALUEFUNC(_wrap_TrdType_SPECIAL_CUM_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_GUARANTEED_DELIVERY", VALUEFUNC(_wrap_TrdType_GUARANTEED_DELIVERY_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PROROGATION_SELL", VALUEFUNC(_wrap_TrdType_PROROGATION_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PRIOR_REFERENCE_PRICE_TRADE", VALUEFUNC(_wrap_TrdType_PRIOR_REFERENCE_PRICE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PORTFOLIO_TRADE", VALUEFUNC(_wrap_TrdType_PORTFOLIO_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_WORKED_PRINCIPAL_TRADE", VALUEFUNC(_wrap_TrdType_WORKED_PRINCIPAL_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PORTFOLIO_TRANSFER", VALUEFUNC(_wrap_TrdType_PORTFOLIO_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_WEIGHTED_AVERAGE_PRICE_TRADE", VALUEFUNC(_wrap_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS", VALUEFUNC(_wrap_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_COUPON", VALUEFUNC(_wrap_TrdType_SPECIAL_CUM_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_T_TRADE", VALUEFUNC(_wrap_TrdType_T_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADE", VALUEFUNC(_wrap_TrdType_BLOCK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OTC", VALUEFUNC(_wrap_TrdType_OTC_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_AFTER_HOURS_TRADE", VALUEFUNC(_wrap_TrdType_AFTER_HOURS_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_DERIVATIVE_RELATED_TRANSACTION", VALUEFUNC(_wrap_TrdType_DERIVATIVE_RELATED_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_REPURCHASE_AGREEMENT", VALUEFUNC(_wrap_TrdType_REPURCHASE_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_RIGHTS", VALUEFUNC(_wrap_TrdType_SPECIAL_EX_RIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PROROGATION_BUY", VALUEFUNC(_wrap_TrdType_PROROGATION_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OPTION_CABINET_TRADE", VALUEFUNC(_wrap_TrdType_OPTION_CABINET_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BUNCHED_TRADE", VALUEFUNC(_wrap_TrdType_BUNCHED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_MODIFIED_MOD_RESTRUCTURING", VALUEFUNC(_wrap_RestructuringType_MODIFIED_MOD_RESTRUCTURING_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_FULL_RESTRUCTURING", VALUEFUNC(_wrap_RestructuringType_FULL_RESTRUCTURING_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_NO_RESTRUCTURING_SPECIFIED", VALUEFUNC(_wrap_RestructuringType_NO_RESTRUCTURING_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_MODIFIED_RESTRUCTURING", VALUEFUNC(_wrap_RestructuringType_MODIFIED_RESTRUCTURING_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_REAL_TIME_EXECUTION_REPORTS", VALUEFUNC(_wrap_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST", VALUEFUNC(_wrap_ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD", VALUEFUNC(_wrap_ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST", VALUEFUNC(_wrap_ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD", VALUEFUNC(_wrap_ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_EVENING", VALUEFUNC(_wrap_TradingSessionID_EVENING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_AFTER_HOURS", VALUEFUNC(_wrap_TradingSessionID_AFTER_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_HALFDAY", VALUEFUNC(_wrap_TradingSessionID_HALFDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_DAY", VALUEFUNC(_wrap_TradingSessionID_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_MORNING", VALUEFUNC(_wrap_TradingSessionID_MORNING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_AFTERNOON", VALUEFUNC(_wrap_TradingSessionID_AFTERNOON_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_CANCELING", VALUEFUNC(_wrap_ListOrderStatus_CANCELING_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_REJECT", VALUEFUNC(_wrap_ListOrderStatus_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_ALL_DONE", VALUEFUNC(_wrap_ListOrderStatus_ALL_DONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_IN_BIDDING_PROCESS", VALUEFUNC(_wrap_ListOrderStatus_IN_BIDDING_PROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_RECEIVED_FOR_EXECUTION", VALUEFUNC(_wrap_ListOrderStatus_RECEIVED_FOR_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_ALERT", VALUEFUNC(_wrap_ListOrderStatus_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_RECEIVEDFOREXECUTION", VALUEFUNC(_wrap_ListOrderStatus_RECEIVEDFOREXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_INBIDDINGPROCESS", VALUEFUNC(_wrap_ListOrderStatus_INBIDDINGPROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_CANCELLING", VALUEFUNC(_wrap_ListOrderStatus_CANCELLING_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_EXECUTING", VALUEFUNC(_wrap_ListOrderStatus_EXECUTING_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REJECT", VALUEFUNC(_wrap_RegistStatus_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING", VALUEFUNC(_wrap_RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REJECTED", VALUEFUNC(_wrap_RegistStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_ACCEPTED", VALUEFUNC(_wrap_RegistStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REMINDER", VALUEFUNC(_wrap_RegistStatus_REMINDER_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_HELD", VALUEFUNC(_wrap_RegistStatus_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_ACCEPT", VALUEFUNC(_wrap_RegistStatus_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE", VALUEFUNC(_wrap_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE", VALUEFUNC(_wrap_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_AVERAGE_VALUE", VALUEFUNC(_wrap_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_REGULAR", VALUEFUNC(_wrap_UnderlyingPriceDeterminationMethod_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ALL_ORDERS", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE", VALUEFUNC(_wrap_MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejResponseTo_ORDER_CANCEL_REQUEST", VALUEFUNC(_wrap_CxlRejResponseTo_ORDER_CANCEL_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST", VALUEFUNC(_wrap_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_BY_QUOTETYPE", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_BY_QUOTETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_ALL_QUOTES", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_ALL_QUOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_ALL_QUOTES", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_ALL_QUOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_SECURITY_TYPE", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_SYMBOL", VALUEFUNC(_wrap_QuoteCancelType_CANCEL_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YIELD_TO_MATURITY", VALUEFUNC(_wrap_StipulationType_YIELD_TO_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ALTERNATIVE_MINIMUM_TAX", VALUEFUNC(_wrap_StipulationType_ALTERNATIVE_MINIMUM_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_GEOGRAPHICS_AND_RANGE", VALUEFUNC(_wrap_StipulationType_GEOGRAPHICS_AND_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_COUPON_RANGE", VALUEFUNC(_wrap_StipulationType_COUPON_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BANK_QUALIFIED", VALUEFUNC(_wrap_StipulationType_BANK_QUALIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_RATING_SOURCE_AND_RANGE", VALUEFUNC(_wrap_StipulationType_RATING_SOURCE_AND_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SUBSTITUTIONS_FREQUENCY", VALUEFUNC(_wrap_StipulationType_SUBSTITUTIONS_FREQUENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUM_DENOMINATION", VALUEFUNC(_wrap_StipulationType_MINIMUM_DENOMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET", VALUEFUNC(_wrap_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUM_ORDER_SIZE", VALUEFUNC(_wrap_StipulationType_MAXIMUM_ORDER_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ABSOLUTE_PREPAYMENT_SPEED", VALUEFUNC(_wrap_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRICING_FREQUENCY", VALUEFUNC(_wrap_StipulationType_PRICING_FREQUENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANT_PREPAYMENT_YIELD", VALUEFUNC(_wrap_StipulationType_CONSTANT_PREPAYMENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YIELD_RANGE", VALUEFUNC(_wrap_StipulationType_YIELD_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE", VALUEFUNC(_wrap_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BENCHMARK_PRICE_SOURCE", VALUEFUNC(_wrap_StipulationType_BENCHMARK_PRICE_SOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUM_SUBSTITUTIONS", VALUEFUNC(_wrap_StipulationType_MAXIMUM_SUBSTITUTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MONTHLY_PREPAYMENT_RATE", VALUEFUNC(_wrap_StipulationType_MONTHLY_PREPAYMENT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PURPOSE", VALUEFUNC(_wrap_StipulationType_PURPOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WHOLE_POOL", VALUEFUNC(_wrap_StipulationType_WHOLE_POOL_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LOAN_AGE", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_MAXIMUM", VALUEFUNC(_wrap_StipulationType_POOLS_MAXIMUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUM_QUANTITY", VALUEFUNC(_wrap_StipulationType_MINIMUM_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_VALUATION_DISCOUNT", VALUEFUNC(_wrap_StipulationType_VALUATION_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_GEOGRAPHICS", VALUEFUNC(_wrap_StipulationType_GEOGRAPHICS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AMT", VALUEFUNC(_wrap_StipulationType_AMT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_MATURITY", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CALL_PROTECTION", VALUEFUNC(_wrap_StipulationType_CALL_PROTECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_EXPLICIT_LOT_IDENTIFIER", VALUEFUNC(_wrap_StipulationType_EXPLICIT_LOT_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_FREEFORM_TEXT", VALUEFUNC(_wrap_StipulationType_FREEFORM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TRADE_VARIANCE", VALUEFUNC(_wrap_StipulationType_TRADE_VARIANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS", VALUEFUNC(_wrap_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_STRUCTURE", VALUEFUNC(_wrap_StipulationType_STRUCTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_RESTRICTED", VALUEFUNC(_wrap_StipulationType_RESTRICTED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANT_PREPAYMENT_PENALTY", VALUEFUNC(_wrap_StipulationType_CONSTANT_PREPAYMENT_PENALTY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS", VALUEFUNC(_wrap_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE", VALUEFUNC(_wrap_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TYPE_OF_REDEMPTION", VALUEFUNC(_wrap_StipulationType_TYPE_OF_REDEMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED", VALUEFUNC(_wrap_StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PAYMENT_FREQUENCY_CALENDAR", VALUEFUNC(_wrap_StipulationType_PAYMENT_FREQUENCY_CALENDAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER", VALUEFUNC(_wrap_StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISSUERS_TICKER", VALUEFUNC(_wrap_StipulationType_ISSUERS_TICKER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUM_LOAN_BALANCE", VALUEFUNC(_wrap_StipulationType_MAXIMUM_LOAN_BALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BROKER_SALES_CREDIT_OVERRIDE", VALUEFUNC(_wrap_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OF_BMA_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_OF_BMA_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISO_CURRENCY_CODE", VALUEFUNC(_wrap_StipulationType_ISO_CURRENCY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MARKET_SECTOR", VALUEFUNC(_wrap_StipulationType_MARKET_SECTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOL_IDENTIFIER", VALUEFUNC(_wrap_StipulationType_POOL_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TYPE_OF_ROLL_TRADE", VALUEFUNC(_wrap_StipulationType_TYPE_OF_ROLL_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED", VALUEFUNC(_wrap_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YEAR_OF_ISSUE", VALUEFUNC(_wrap_StipulationType_YEAR_OF_ISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_LOOKBACK_DAYS", VALUEFUNC(_wrap_StipulationType_LOOKBACK_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE", VALUEFUNC(_wrap_StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITY_YEAR", VALUEFUNC(_wrap_StipulationType_MATURITY_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CUSTOM_START_END_DATE", VALUEFUNC(_wrap_StipulationType_CUSTOM_START_END_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ORDER_QUANTITY_INCREMENT", VALUEFUNC(_wrap_StipulationType_ORDER_QUANTITY_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_DISCOUNT_RATE", VALUEFUNC(_wrap_StipulationType_DISCOUNT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANT_PREPAYMENT_RATE", VALUEFUNC(_wrap_StipulationType_CONSTANT_PREPAYMENT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AVERAGE_LOAN_SIZE", VALUEFUNC(_wrap_StipulationType_AVERAGE_LOAN_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TRADERS_CREDIT", VALUEFUNC(_wrap_StipulationType_TRADERS_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_PER_LOT", VALUEFUNC(_wrap_StipulationType_POOLS_PER_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LIFE", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_LIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITY_RANGE", VALUEFUNC(_wrap_StipulationType_MATURITY_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_PER_MILLION", VALUEFUNC(_wrap_StipulationType_POOLS_PER_MILLION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_LOT_VARIANCE", VALUEFUNC(_wrap_StipulationType_LOT_VARIANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR", VALUEFUNC(_wrap_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AVERAGE_FICO_SCORE", VALUEFUNC(_wrap_StipulationType_AVERAGE_FICO_SCORE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRICE_RANGE", VALUEFUNC(_wrap_StipulationType_PRICE_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITY_YEAR_AND_MONTH", VALUEFUNC(_wrap_StipulationType_MATURITY_YEAR_AND_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUM_INCREMENT", VALUEFUNC(_wrap_StipulationType_MINIMUM_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_COUPON", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE", VALUEFUNC(_wrap_StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SUBSTITUTIONS_LEFT", VALUEFUNC(_wrap_StipulationType_SUBSTITUTIONS_LEFT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_NUMBER_OF_PIECES", VALUEFUNC(_wrap_StipulationType_NUMBER_OF_PIECES_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_INSURED", VALUEFUNC(_wrap_StipulationType_INSURED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE", VALUEFUNC(_wrap_StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY", VALUEFUNC(_wrap_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BARGAIN_CONDITIONS", VALUEFUNC(_wrap_StipulationType_BARGAIN_CONDITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_PER_TRADE", VALUEFUNC(_wrap_StipulationType_POOLS_PER_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS", VALUEFUNC(_wrap_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SINGLE_MONTHLY_MORTALITY", VALUEFUNC(_wrap_StipulationType_SINGLE_MONTHLY_MORTALITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE", VALUEFUNC(_wrap_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BROKERS_SALES_CREDIT", VALUEFUNC(_wrap_StipulationType_BROKERS_SALES_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISSUE_SIZE_RANGE", VALUEFUNC(_wrap_StipulationType_ISSUE_SIZE_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BARGAIN_CONDITIONS_SEE", VALUEFUNC(_wrap_StipulationType_BARGAIN_CONDITIONS_SEE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRODUCTION_YEAR", VALUEFUNC(_wrap_StipulationType_PRODUCTION_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_PERCENT_OF_PAR", VALUEFUNC(_wrap_PriceQuoteMethod_PERCENT_OF_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL", VALUEFUNC(_wrap_PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_INDEX", VALUEFUNC(_wrap_PriceQuoteMethod_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_INTEREST_RATE_INDEX", VALUEFUNC(_wrap_PriceQuoteMethod_INTEREST_RATE_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER", VALUEFUNC(_wrap_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_COMPID_PROBLEM", VALUEFUNC(_wrap_SessionRejectReason_COMPID_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SIGNATURE_PROBLEM", VALUEFUNC(_wrap_SessionRejectReason_SIGNATURE_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE", VALUEFUNC(_wrap_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_XML_VALIDATION_ERROR", VALUEFUNC(_wrap_SessionRejectReason_XML_VALIDATION_ERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_UNDEFINED_TAG", VALUEFUNC(_wrap_SessionRejectReason_UNDEFINED_TAG_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE", VALUEFUNC(_wrap_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER", VALUEFUNC(_wrap_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REQUIRED_TAG_MISSING", VALUEFUNC(_wrap_SessionRejectReason_REQUIRED_TAG_MISSING_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_OTHER", VALUEFUNC(_wrap_SessionRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP", VALUEFUNC(_wrap_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE", VALUEFUNC(_wrap_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER", VALUEFUNC(_wrap_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_DECRYPTION_PROBLEM", VALUEFUNC(_wrap_SessionRejectReason_DECRYPTION_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_TAG_NUMBER", VALUEFUNC(_wrap_SessionRejectReason_INVALID_TAG_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_VALUE_IS_INCORRECT", VALUEFUNC(_wrap_SessionRejectReason_VALUE_IS_INCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE", VALUEFUNC(_wrap_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_MSGTYPE", VALUEFUNC(_wrap_SessionRejectReason_INVALID_MSGTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM", VALUEFUNC(_wrap_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_TRI_PARTY", VALUEFUNC(_wrap_DeliveryType_TRI_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_HOLD_IN_CUSTODY", VALUEFUNC(_wrap_DeliveryType_HOLD_IN_CUSTODY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_FREE_DELIVER", VALUEFUNC(_wrap_DeliveryType_FREE_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_VERSUS_PAYMENT_DELIVER", VALUEFUNC(_wrap_DeliveryType_VERSUS_PAYMENT_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_LOCAL", VALUEFUNC(_wrap_Scope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_LOCAL_MARKET", VALUEFUNC(_wrap_Scope_LOCAL_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_GLOBAL", VALUEFUNC(_wrap_Scope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_NATIONAL", VALUEFUNC(_wrap_Scope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_CANCELLATION", VALUEFUNC(_wrap_DeleteReason_CANCELLATION_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_CANCELATION", VALUEFUNC(_wrap_DeleteReason_CANCELATION_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_ERROR", VALUEFUNC(_wrap_DeleteReason_ERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "InViewOfCommon_NO", VALUEFUNC(_wrap_InViewOfCommon_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "InViewOfCommon_YES", VALUEFUNC(_wrap_InViewOfCommon_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "NoSides_ONE_SIDE", VALUEFUNC(_wrap_NoSides_ONE_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "NoSides_BOTH_SIDES", VALUEFUNC(_wrap_NoSides_BOTH_SIDES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_CERTIFICATE_OF_DEPOSIT", VALUEFUNC(_wrap_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MUNICIPAL_BOND", VALUEFUNC(_wrap_SecurityType_MUNICIPAL_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_INTEREST_ONLY", VALUEFUNC(_wrap_SecurityType_MORTGAGE_INTEREST_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MATURED", VALUEFUNC(_wrap_SecurityType_MATURED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FUTURE", VALUEFUNC(_wrap_SecurityType_FUTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURY_BILL", VALUEFUNC(_wrap_SecurityType_TREASURY_BILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BILL_OF_EXCHANGES", VALUEFUNC(_wrap_SecurityType_BILL_OF_EXCHANGES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TIME_DEPOSIT", VALUEFUNC(_wrap_SecurityType_TIME_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_IOETTE", VALUEFUNC(_wrap_SecurityType_MORTGAGE_IOETTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REPURCHASE_AGREEMENT", VALUEFUNC(_wrap_SecurityType_REPURCHASE_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIAL_OBLIGATION", VALUEFUNC(_wrap_SecurityType_SPECIAL_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COMMERCIAL_PAPER", VALUEFUNC(_wrap_SecurityType_COMMERCIAL_PAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPORATE_BOND", VALUEFUNC(_wrap_SecurityType_CORPORATE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORP_MORTGAGE_BACKED_SECURITIES", VALUEFUNC(_wrap_SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC", VALUEFUNC(_wrap_SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_STRUCTURED_NOTES", VALUEFUNC(_wrap_SecurityType_STRUCTURED_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REPURCHASE", VALUEFUNC(_wrap_SecurityType_REPURCHASE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_MORTGAGE_BONDS", VALUEFUNC(_wrap_SecurityType_CANADIAN_MORTGAGE_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE", VALUEFUNC(_wrap_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE", VALUEFUNC(_wrap_SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_REVENUE_ANTICIPATION_NOTE", VALUEFUNC(_wrap_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BILL", VALUEFUNC(_wrap_SecurityType_US_TREASURY_BILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PLAZOS_FIJOS", VALUEFUNC(_wrap_SecurityType_PLAZOS_FIJOS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_TREASURY_NOTES", VALUEFUNC(_wrap_SecurityType_CANADIAN_TREASURY_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_YANKEE_CORPORATE_BOND", VALUEFUNC(_wrap_SecurityType_YANKEE_CORPORATE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE", VALUEFUNC(_wrap_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BUY_SELLBACK", VALUEFUNC(_wrap_SecurityType_BUY_SELLBACK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NO_ISITC_SECURITY_TYPE", VALUEFUNC(_wrap_SecurityType_NO_ISITC_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PROMISSORY_NOTE", VALUEFUNC(_wrap_SecurityType_PROMISSORY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRIVATE_EXPORT_FUNDING", VALUEFUNC(_wrap_SecurityType_PRIVATE_EXPORT_FUNDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CASH", VALUEFUNC(_wrap_SecurityType_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEPOSIT_NOTES", VALUEFUNC(_wrap_SecurityType_DEPOSIT_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FOREIGN_EXCHANGE_CONTRACT", VALUEFUNC(_wrap_SecurityType_FOREIGN_EXCHANGE_CONTRACT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURITIES_PLEDGE", VALUEFUNC(_wrap_SecurityType_SECURITIES_PLEDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_RETIRED", VALUEFUNC(_wrap_SecurityType_RETIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OVERNIGHT", VALUEFUNC(_wrap_SecurityType_OVERNIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVENUE_ANTICIPATION_NOTE", VALUEFUNC(_wrap_SecurityType_REVENUE_ANTICIPATION_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVERSE_REPURCHASE_AGREEMENT", VALUEFUNC(_wrap_SecurityType_REVERSE_REPURCHASE_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION", VALUEFUNC(_wrap_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WARRANT", VALUEFUNC(_wrap_SecurityType_WARRANT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_LIQUIDITY_NOTE", VALUEFUNC(_wrap_SecurityType_LIQUIDITY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MANDATORY_TENDER", VALUEFUNC(_wrap_SecurityType_MANDATORY_TENDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COMMON_STOCK", VALUEFUNC(_wrap_SecurityType_COMMON_STOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_CORPORATE_BOND", VALUEFUNC(_wrap_SecurityType_EURO_CORPORATE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CALL_LOANS", VALUEFUNC(_wrap_SecurityType_CALL_LOANS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTIONS_ON_PHYSICAL", VALUEFUNC(_wrap_SecurityType_OPTIONS_ON_PHYSICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVOLVER_LOAN", VALUEFUNC(_wrap_SecurityType_REVOLVER_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTION", VALUEFUNC(_wrap_SecurityType_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_AGENCY_COUPON", VALUEFUNC(_wrap_SecurityType_FEDERAL_AGENCY_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_ALLOCATION", VALUEFUNC(_wrap_SecurityType_TAX_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MISCELLANEOUS_PASS_THROUGH", VALUEFUNC(_wrap_SecurityType_MISCELLANEOUS_PASS_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_VARIABLE_RATE_DEMAND_NOTE", VALUEFUNC(_wrap_SecurityType_VARIABLE_RATE_DEMAND_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_PRINCIPAL_ONLY", VALUEFUNC(_wrap_SecurityType_MORTGAGE_PRINCIPAL_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAXABLE_MUNICIPAL_CP", VALUEFUNC(_wrap_SecurityType_TAXABLE_MUNICIPAL_CP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INTEREST_RATE_SWAP", VALUEFUNC(_wrap_SecurityType_INTEREST_RATE_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANK_NOTES", VALUEFUNC(_wrap_SecurityType_BANK_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_ASSET_BACKED_SECURITIES", VALUEFUNC(_wrap_SecurityType_ASSET_BACKED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MULTILEG_INSTRUMENT", VALUEFUNC(_wrap_SecurityType_MULTILEG_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE", VALUEFUNC(_wrap_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CREDIT_DEFAULT_SWAP", VALUEFUNC(_wrap_SecurityType_CREDIT_DEFAULT_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION", VALUEFUNC(_wrap_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USD_SUPRANATIONAL_COUPONS", VALUEFUNC(_wrap_SecurityType_USD_SUPRANATIONAL_COUPONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVOLVER_TERM_LOAN", VALUEFUNC(_wrap_SecurityType_REVOLVER_TERM_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_PRINCIPLE_ONLY", VALUEFUNC(_wrap_SecurityType_MORTGAGE_PRINCIPLE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REPLACED", VALUEFUNC(_wrap_SecurityType_REPLACED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BILL_TBILL", VALUEFUNC(_wrap_SecurityType_US_TREASURY_BILL_TBILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATE_OF_DEPOSIT", VALUEFUNC(_wrap_SecurityType_CERTIFICATE_OF_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIAL_ASSESSMENT", VALUEFUNC(_wrap_SecurityType_SPECIAL_ASSESSMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SHORT_TERM_LOAN_NOTE", VALUEFUNC(_wrap_SecurityType_SHORT_TERM_LOAN_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_LETTER_OF_CREDIT", VALUEFUNC(_wrap_SecurityType_LETTER_OF_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTIONS_ON_COMBO", VALUEFUNC(_wrap_SecurityType_OPTIONS_ON_COMBO_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIAL_TAX", VALUEFUNC(_wrap_SecurityType_SPECIAL_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PREFERRED_STOCK", VALUEFUNC(_wrap_SecurityType_PREFERRED_STOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_NOTE_TNOTE", VALUEFUNC(_wrap_SecurityType_US_TREASURY_NOTE_TNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_AGENCY_POOLS", VALUEFUNC(_wrap_SecurityType_AGENCY_POOLS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MEDIUM_TERM_NOTES", VALUEFUNC(_wrap_SecurityType_MEDIUM_TERM_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_PROVINCIAL_BONDS", VALUEFUNC(_wrap_SecurityType_CANADIAN_PROVINCIAL_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_IOETTE_MORTGAGE", VALUEFUNC(_wrap_SecurityType_IOETTE_MORTGAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION", VALUEFUNC(_wrap_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURITIES_LOAN", VALUEFUNC(_wrap_SecurityType_SECURITIES_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES", VALUEFUNC(_wrap_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATE_OF_PARTICIPATION", VALUEFUNC(_wrap_SecurityType_CERTIFICATE_OF_PARTICIPATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_HOME_LOAN", VALUEFUNC(_wrap_SecurityType_FEDERAL_HOME_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_CORPORATE_FLOATING_RATE_NOTES", VALUEFUNC(_wrap_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT", VALUEFUNC(_wrap_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MULTI_LEG_INSTRUMENT", VALUEFUNC(_wrap_SecurityType_MULTI_LEG_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WITHDRAWN", VALUEFUNC(_wrap_SecurityType_WITHDRAWN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MISCELLANEOUS_PASS_THRU", VALUEFUNC(_wrap_SecurityType_MISCELLANEOUS_PASS_THRU_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_MONEY_MARKETS", VALUEFUNC(_wrap_SecurityType_CANADIAN_MONEY_MARKETS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FORWARD", VALUEFUNC(_wrap_SecurityType_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_SUPRANATIONAL_COUPONS", VALUEFUNC(_wrap_SecurityType_EURO_SUPRANATIONAL_COUPONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE", VALUEFUNC(_wrap_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_SOVEREIGNS", VALUEFUNC(_wrap_SecurityType_EURO_SOVEREIGNS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATE_OF_OBLIGATION", VALUEFUNC(_wrap_SecurityType_CERTIFICATE_OF_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANK_DEPOSITORY_NOTE", VALUEFUNC(_wrap_SecurityType_BANK_DEPOSITORY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BILL_USTB", VALUEFUNC(_wrap_SecurityType_US_TREASURY_BILL_USTB_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FX_SWAP", VALUEFUNC(_wrap_SecurityType_FX_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WILDCARD_ENTRY", VALUEFUNC(_wrap_SecurityType_WILDCARD_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SWING_LINE_FACILITY", VALUEFUNC(_wrap_SecurityType_SWING_LINE_FACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_HOUSING_AUTHORITY", VALUEFUNC(_wrap_SecurityType_FEDERAL_HOUSING_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPORATE_PRIVATE_PLACEMENT", VALUEFUNC(_wrap_SecurityType_CORPORATE_PRIVATE_PLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_GENERAL_OBLIGATION_BONDS", VALUEFUNC(_wrap_SecurityType_GENERAL_OBLIGATION_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST", VALUEFUNC(_wrap_SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INDEXED_LINKED", VALUEFUNC(_wrap_SecurityType_INDEXED_LINKED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TO_BE_ANNOUNCED", VALUEFUNC(_wrap_SecurityType_TO_BE_ANNOUNCED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES", VALUEFUNC(_wrap_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NON_DELIVERABLE_FORWARD", VALUEFUNC(_wrap_SecurityType_NON_DELIVERABLE_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTIONS_ON_FUTURES", VALUEFUNC(_wrap_SecurityType_OPTIONS_ON_FUTURES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_ANTICIPATION_NOTE", VALUEFUNC(_wrap_SecurityType_TAX_ANTICIPATION_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TERM_LOAN", VALUEFUNC(_wrap_SecurityType_TERM_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_AMENDED_RESTATED", VALUEFUNC(_wrap_SecurityType_AMENDED_RESTATED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FX_FORWARD", VALUEFUNC(_wrap_SecurityType_FX_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_TREASURY_BILLS", VALUEFUNC(_wrap_SecurityType_CANADIAN_TREASURY_BILLS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DUAL_CURRENCY", VALUEFUNC(_wrap_SecurityType_DUAL_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_PRIVATE_PLACEMENT", VALUEFUNC(_wrap_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_COMMERCIAL_PAPER", VALUEFUNC(_wrap_SecurityType_EURO_COMMERCIAL_PAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION", VALUEFUNC(_wrap_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BOND", VALUEFUNC(_wrap_SecurityType_US_TREASURY_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURED_LIQUIDITY_NOTE", VALUEFUNC(_wrap_SecurityType_SECURED_LIQUIDITY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_BACKED_SECURITIES", VALUEFUNC(_wrap_SecurityType_MORTGAGE_BACKED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_NOTE_UST", VALUEFUNC(_wrap_SecurityType_US_TREASURY_NOTE_UST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEBTOR_IN_POSSESSION", VALUEFUNC(_wrap_SecurityType_DEBTOR_IN_POSSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TERM_LIQUIDITY_NOTE", VALUEFUNC(_wrap_SecurityType_TERM_LIQUIDITY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_NOTE_BOND", VALUEFUNC(_wrap_SecurityType_US_TREASURY_NOTE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVENUE_BONDS", VALUEFUNC(_wrap_SecurityType_REVENUE_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BRIDGE_LOAN", VALUEFUNC(_wrap_SecurityType_BRIDGE_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CATS_TIGERS_LIONS", VALUEFUNC(_wrap_SecurityType_CATS_TIGERS_LIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BRADY_BOND", VALUEFUNC(_wrap_SecurityType_BRADY_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NO_SECURITY_TYPE", VALUEFUNC(_wrap_SecurityType_NO_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER", VALUEFUNC(_wrap_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION", VALUEFUNC(_wrap_SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEFAULTED", VALUEFUNC(_wrap_SecurityType_DEFAULTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OTHER_ANTICIPATION_NOTES", VALUEFUNC(_wrap_SecurityType_OTHER_ANTICIPATION_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MUTUAL_FUND", VALUEFUNC(_wrap_SecurityType_MUTUAL_FUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EXTENDED_COMM_NOTE", VALUEFUNC(_wrap_SecurityType_EXTENDED_COMM_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CONVERTIBLE_BOND", VALUEFUNC(_wrap_SecurityType_CONVERTIBLE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PFANDBRIEFE", VALUEFUNC(_wrap_SecurityType_PFANDBRIEFE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FX_SPOT", VALUEFUNC(_wrap_SecurityType_FX_SPOT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANKERS_ACCEPTANCE", VALUEFUNC(_wrap_SecurityType_BANKERS_ACCEPTANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUND_DOWN", VALUEFUNC(_wrap_RoundingDirection_ROUND_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUND_TO_NEAREST", VALUEFUNC(_wrap_RoundingDirection_ROUND_TO_NEAREST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUND_UP", VALUEFUNC(_wrap_RoundingDirection_ROUND_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_MINUTE", VALUEFUNC(_wrap_TimeUnit_MINUTE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_WEEK", VALUEFUNC(_wrap_TimeUnit_WEEK_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_SECOND", VALUEFUNC(_wrap_TimeUnit_SECOND_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_MONTH", VALUEFUNC(_wrap_TimeUnit_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_HOUR", VALUEFUNC(_wrap_TimeUnit_HOUR_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_DAY", VALUEFUNC(_wrap_TimeUnit_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_YEAR", VALUEFUNC(_wrap_TimeUnit_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_MODIFIED_DURATION", VALUEFUNC(_wrap_LegSwapType_MODIFIED_DURATION_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_RISK", VALUEFUNC(_wrap_LegSwapType_RISK_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_PAR_FOR_PAR", VALUEFUNC(_wrap_LegSwapType_PAR_FOR_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_PROCEEDS", VALUEFUNC(_wrap_LegSwapType_PROCEEDS_get), 0);
  rb_define_singleton_method(mQuickfix, "IOITransType_REPLACE", VALUEFUNC(_wrap_IOITransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOITransType_NEW", VALUEFUNC(_wrap_IOITransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "IOITransType_CANCEL", VALUEFUNC(_wrap_IOITransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_VALID_REQUEST", VALUEFUNC(_wrap_PosReqResult_VALID_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS", VALUEFUNC(_wrap_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA", VALUEFUNC(_wrap_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST", VALUEFUNC(_wrap_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_OTHER", VALUEFUNC(_wrap_PosReqResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED", VALUEFUNC(_wrap_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_DEFAULT", VALUEFUNC(_wrap_SettlInstMode_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_REQUEST_REJECT", VALUEFUNC(_wrap_SettlInstMode_REQUEST_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING", VALUEFUNC(_wrap_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING", VALUEFUNC(_wrap_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT", VALUEFUNC(_wrap_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED", VALUEFUNC(_wrap_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "PreviouslyReported_NO", VALUEFUNC(_wrap_PreviouslyReported_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PreviouslyReported_YES", VALUEFUNC(_wrap_PreviouslyReported_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_PEGGED", VALUEFUNC(_wrap_CustOrderHandlingInst_PEGGED_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_ON_OPEN", VALUEFUNC(_wrap_CustOrderHandlingInst_MARKET_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_SCALE", VALUEFUNC(_wrap_CustOrderHandlingInst_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_FILL_OR_KILL", VALUEFUNC(_wrap_CustOrderHandlingInst_FILL_OR_KILL_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_ALL_OR_NONE", VALUEFUNC(_wrap_CustOrderHandlingInst_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_NOT_HELD", VALUEFUNC(_wrap_CustOrderHandlingInst_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_DIRECTED_ORDER", VALUEFUNC(_wrap_CustOrderHandlingInst_DIRECTED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_STOP_STOCK_TRANSACTION", VALUEFUNC(_wrap_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_OVER_THE_DAY", VALUEFUNC(_wrap_CustOrderHandlingInst_OVER_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_ADD_ON_ORDER", VALUEFUNC(_wrap_CustOrderHandlingInst_ADD_ON_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_AT_CLOSE", VALUEFUNC(_wrap_CustOrderHandlingInst_MARKET_AT_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_LIMIT_ON_OPEN", VALUEFUNC(_wrap_CustOrderHandlingInst_LIMIT_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_CASH_NOT_HELD", VALUEFUNC(_wrap_CustOrderHandlingInst_CASH_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_ON_CLOSE", VALUEFUNC(_wrap_CustOrderHandlingInst_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_TIME_ORDER", VALUEFUNC(_wrap_CustOrderHandlingInst_TIME_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_LIMIT_ON_CLOSE", VALUEFUNC(_wrap_CustOrderHandlingInst_LIMIT_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_IMMEDIATE_OR_CANCEL", VALUEFUNC(_wrap_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_TRAILING_STOP", VALUEFUNC(_wrap_CustOrderHandlingInst_TRAILING_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_WORK", VALUEFUNC(_wrap_CustOrderHandlingInst_WORK_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_RESERVE_SIZE_ORDER", VALUEFUNC(_wrap_CustOrderHandlingInst_RESERVE_SIZE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MINIMUM_QUANTITY", VALUEFUNC(_wrap_CustOrderHandlingInst_MINIMUM_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_AT_OPEN", VALUEFUNC(_wrap_CustOrderHandlingInst_MARKET_AT_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_IMBALANCE_ONLY", VALUEFUNC(_wrap_CustOrderHandlingInst_IMBALANCE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION", VALUEFUNC(_wrap_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityStatus_INACTIVE", VALUEFUNC(_wrap_SecurityStatus_INACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityStatus_ACTIVE", VALUEFUNC(_wrap_SecurityStatus_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFT_DOLLAR", VALUEFUNC(_wrap_ProcessCode_SOFT_DOLLAR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_PLAN_SPONSOR", VALUEFUNC(_wrap_ProcessCode_PLAN_SPONSOR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEP_IN", VALUEFUNC(_wrap_ProcessCode_STEP_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_REGULAR", VALUEFUNC(_wrap_ProcessCode_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFT_DOLLAR_STEP_OUT", VALUEFUNC(_wrap_ProcessCode_SOFT_DOLLAR_STEP_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEP_OUT", VALUEFUNC(_wrap_ProcessCode_STEP_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFT_DOLLAR_STEP_IN", VALUEFUNC(_wrap_ProcessCode_SOFT_DOLLAR_STEP_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRY_TO_STOP", VALUEFUNC(_wrap_ExecInst_TRY_TO_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEG_TO_LIMIT_PRICE", VALUEFUNC(_wrap_ExecInst_PEG_TO_LIMIT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXECUTE_AS_DURATION_NEUTRAL", VALUEFUNC(_wrap_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_TRADING_HALT", VALUEFUNC(_wrap_ExecInst_REINSTATE_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NO_CROSS", VALUEFUNC(_wrap_ExecInst_NO_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEGVWAP", VALUEFUNC(_wrap_ExecInst_PEGVWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICT_SCALE", VALUEFUNC(_wrap_ExecInst_STRICT_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_AON", VALUEFUNC(_wrap_ExecInst_AON_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MARKPEG", VALUEFUNC(_wrap_ExecInst_MARKPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MIDPRCPEG", VALUEFUNC(_wrap_ExecInst_MIDPRCPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OKCROSS", VALUEFUNC(_wrap_ExecInst_OKCROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRAILING_STOP_PEG", VALUEFUNC(_wrap_ExecInst_TRAILING_STOP_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXECUTE_AS_FX_NEUTRAL", VALUEFUNC(_wrap_ExecInst_EXECUTE_AS_FX_NEUTRAL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CUSTDISPINST", VALUEFUNC(_wrap_ExecInst_CUSTDISPINST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OK_TO_CROSS", VALUEFUNC(_wrap_ExecInst_OK_TO_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND_ON_SYSTEM_FAILURE", VALUEFUNC(_wrap_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_GO_ALONG", VALUEFUNC(_wrap_ExecInst_GO_ALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_INSTITONLY", VALUEFUNC(_wrap_ExecInst_INSTITONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DO_NOT_INCREASE", VALUEFUNC(_wrap_ExecInst_DO_NOT_INCREASE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND", VALUEFUNC(_wrap_ExecInst_SUSPEND_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRYTOSTOP", VALUEFUNC(_wrap_ExecInst_TRYTOSTOP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER", VALUEFUNC(_wrap_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_SYSTEM_FAILURE", VALUEFUNC(_wrap_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND_ON_TRADING_HALT", VALUEFUNC(_wrap_ExecInst_SUSPEND_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_INTERMARKET_SWEEP", VALUEFUNC(_wrap_ExecInst_INTERMARKET_SWEEP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_BEST_EXECUTION", VALUEFUNC(_wrap_ExecInst_BEST_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PARTICIPATE_DONT_INITIATE", VALUEFUNC(_wrap_ExecInst_PARTICIPATE_DONT_INITIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_LASTPEG", VALUEFUNC(_wrap_ExecInst_LASTPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEG_TO_VWAP", VALUEFUNC(_wrap_ExecInst_PEG_TO_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PRIMARY_PEG", VALUEFUNC(_wrap_ExecInst_PRIMARY_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NONNEGO", VALUEFUNC(_wrap_ExecInst_NONNEGO_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_IGNORE_PRICE_VALIDITY_CHECKS", VALUEFUNC(_wrap_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_BID_SIDE", VALUEFUNC(_wrap_ExecInst_STAY_ON_BID_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NOTHELD", VALUEFUNC(_wrap_ExecInst_NOTHELD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICTSCALE", VALUEFUNC(_wrap_ExecInst_STRICTSCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_CONNECTION_LOSS", VALUEFUNC(_wrap_ExecInst_REINSTATE_ON_CONNECTION_LOSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DNI", VALUEFUNC(_wrap_ExecInst_DNI_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRYTOSCALE", VALUEFUNC(_wrap_ExecInst_TRYTOSCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PERCENT_OF_VOLUME", VALUEFUNC(_wrap_ExecInst_PERCENT_OF_VOLUME_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_GOALONG", VALUEFUNC(_wrap_ExecInst_GOALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_WORK", VALUEFUNC(_wrap_ExecInst_WORK_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_HELD", VALUEFUNC(_wrap_ExecInst_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NOCROSS", VALUEFUNC(_wrap_ExecInst_NOCROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_RELEASE_FROM_SUSPENSION", VALUEFUNC(_wrap_ExecInst_RELEASE_FROM_SUSPENSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICT_LIMIT", VALUEFUNC(_wrap_ExecInst_STRICT_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OPENPEG", VALUEFUNC(_wrap_ExecInst_OPENPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_BIDSIDE", VALUEFUNC(_wrap_ExecInst_STAY_ON_BIDSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_OFFERSIDE", VALUEFUNC(_wrap_ExecInst_STAY_ON_OFFERSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OVER_THE_DAY", VALUEFUNC(_wrap_ExecInst_OVER_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_RESTATEONTRADINGHALT", VALUEFUNC(_wrap_ExecInst_RESTATEONTRADINGHALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_INSTITUTIONS_ONLY", VALUEFUNC(_wrap_ExecInst_INSTITUTIONS_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NOT_HELD", VALUEFUNC(_wrap_ExecInst_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCELONTRADINGHALT", VALUEFUNC(_wrap_ExecInst_CANCELONTRADINGHALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCELONSYSFAIL", VALUEFUNC(_wrap_ExecInst_CANCELONSYSFAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MARKET_PEG", VALUEFUNC(_wrap_ExecInst_MARKET_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRADEALONG", VALUEFUNC(_wrap_ExecInst_TRADEALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CALL_FIRST", VALUEFUNC(_wrap_ExecInst_CALL_FIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_ON_SYSTEM_FAILURE", VALUEFUNC(_wrap_ExecInst_CANCEL_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED", VALUEFUNC(_wrap_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE", VALUEFUNC(_wrap_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NON_NEGOTIABLE", VALUEFUNC(_wrap_ExecInst_NON_NEGOTIABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRY_TO_SCALE", VALUEFUNC(_wrap_ExecInst_TRY_TO_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXTERNAL_ROUTING_ALLOWED", VALUEFUNC(_wrap_ExecInst_EXTERNAL_ROUTING_ALLOWED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_OFFER_SIDE", VALUEFUNC(_wrap_ExecInst_STAY_ON_OFFER_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CUSTOMER_DISPLAY_INSTRUCTION", VALUEFUNC(_wrap_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_WORK_TO_TARGET_STRATEGY", VALUEFUNC(_wrap_ExecInst_WORK_TO_TARGET_STRATEGY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OVERDAY", VALUEFUNC(_wrap_ExecInst_OVERDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_LAST_PEG", VALUEFUNC(_wrap_ExecInst_LAST_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CALLFIRST", VALUEFUNC(_wrap_ExecInst_CALLFIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_SYSTEM_FAILUE", VALUEFUNC(_wrap_ExecInst_REINSTATE_ON_SYSTEM_FAILUE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DO_NOT_REDUCE", VALUEFUNC(_wrap_ExecInst_DO_NOT_REDUCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MID_PRICE_PEG", VALUEFUNC(_wrap_ExecInst_MID_PRICE_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_ALL_OR_NONE", VALUEFUNC(_wrap_ExecInst_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OPENING_PEG", VALUEFUNC(_wrap_ExecInst_OPENING_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PERCVOL", VALUEFUNC(_wrap_ExecInst_PERCVOL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND_ON_CONNECTION_LOSS", VALUEFUNC(_wrap_ExecInst_SUSPEND_ON_CONNECTION_LOSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_ON_CONNECTION_LOSS", VALUEFUNC(_wrap_ExecInst_CANCEL_ON_CONNECTION_LOSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED", VALUEFUNC(_wrap_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_IF_NOT_BEST", VALUEFUNC(_wrap_ExecInst_CANCEL_IF_NOT_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PARTNOTINIT", VALUEFUNC(_wrap_ExecInst_PARTNOTINIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NETTING", VALUEFUNC(_wrap_ExecInst_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_IMBALANCE_ONLY", VALUEFUNC(_wrap_ExecInst_IMBALANCE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DNR", VALUEFUNC(_wrap_ExecInst_DNR_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAYOFFER", VALUEFUNC(_wrap_ExecInst_STAYOFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAYBID", VALUEFUNC(_wrap_ExecInst_STAYBID_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRADE_ALONG", VALUEFUNC(_wrap_ExecInst_TRADE_ALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_ON_TRADING_HALT", VALUEFUNC(_wrap_ExecInst_CANCEL_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_RESTATEONSYSFAIL", VALUEFUNC(_wrap_ExecInst_RESTATEONSYSFAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PRIMPEG", VALUEFUNC(_wrap_ExecInst_PRIMPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_REPLACE", VALUEFUNC(_wrap_ExecType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_NEW", VALUEFUNC(_wrap_ExecType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_CALCULATED", VALUEFUNC(_wrap_ExecType_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_CANCEL", VALUEFUNC(_wrap_ExecType_PENDING_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_IN_A_CLEARING_HOLD", VALUEFUNC(_wrap_ExecType_TRADE_IN_A_CLEARING_HOLD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING", VALUEFUNC(_wrap_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_ORDER_STATUS", VALUEFUNC(_wrap_ExecType_ORDER_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_CANCEL_REPLACE", VALUEFUNC(_wrap_ExecType_PENDING_CANCEL_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PARTIAL_FILL", VALUEFUNC(_wrap_ExecType_PARTIAL_FILL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_NEW", VALUEFUNC(_wrap_ExecType_PENDING_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_STOPPED", VALUEFUNC(_wrap_ExecType_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_CANCELED", VALUEFUNC(_wrap_ExecType_CANCELED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_REPLACE", VALUEFUNC(_wrap_ExecType_PENDING_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE", VALUEFUNC(_wrap_ExecType_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_CORRECT", VALUEFUNC(_wrap_ExecType_TRADE_CORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_SUSPENDED", VALUEFUNC(_wrap_ExecType_SUSPENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_FILL", VALUEFUNC(_wrap_ExecType_FILL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_RESTATED", VALUEFUNC(_wrap_ExecType_RESTATED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_REJECTED", VALUEFUNC(_wrap_ExecType_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_REPLACED", VALUEFUNC(_wrap_ExecType_REPLACED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_EXPIRED", VALUEFUNC(_wrap_ExecType_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_DONE_FOR_DAY", VALUEFUNC(_wrap_ExecType_DONE_FOR_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM", VALUEFUNC(_wrap_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_CANCEL", VALUEFUNC(_wrap_ExecType_TRADE_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_CANCELLED", VALUEFUNC(_wrap_ExecType_CANCELLED_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegModel_USER_DEFINED_MULTLEG_SECURITY", VALUEFUNC(_wrap_MultilegModel_USER_DEFINED_MULTLEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegModel_PREDEFINED_MULTILEG_SECURITY", VALUEFUNC(_wrap_MultilegModel_PREDEFINED_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG", VALUEFUNC(_wrap_MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_NEXT_START_DATE", VALUEFUNC(_wrap_EventType_SWAP_NEXT_START_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_LAST_ELIGIBLE_TRADE_DATE", VALUEFUNC(_wrap_EventType_LAST_ELIGIBLE_TRADE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_FIRST_DELIVERY_DATE", VALUEFUNC(_wrap_EventType_FIRST_DELIVERY_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_TENDER", VALUEFUNC(_wrap_EventType_TENDER_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_INITIAL_INVENTORY_DUE_DATE", VALUEFUNC(_wrap_EventType_INITIAL_INVENTORY_DUE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_FIRST_INTENT_DATE", VALUEFUNC(_wrap_EventType_FIRST_INTENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_ACTIVATION", VALUEFUNC(_wrap_EventType_ACTIVATION_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_PUT", VALUEFUNC(_wrap_EventType_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_START_DATE", VALUEFUNC(_wrap_EventType_SWAP_START_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_NEXT_ROLL_DATE", VALUEFUNC(_wrap_EventType_SWAP_NEXT_ROLL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_LAST_DELIVERY_DATE", VALUEFUNC(_wrap_EventType_LAST_DELIVERY_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_POSITION_REMOVAL_DATE", VALUEFUNC(_wrap_EventType_POSITION_REMOVAL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_ROLL_DATE", VALUEFUNC(_wrap_EventType_SWAP_ROLL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_FINAL_INVENTORY_DUE_DATE", VALUEFUNC(_wrap_EventType_FINAL_INVENTORY_DUE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_OTHER", VALUEFUNC(_wrap_EventType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_INACTIVIATION", VALUEFUNC(_wrap_EventType_INACTIVIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_END_DATE", VALUEFUNC(_wrap_EventType_SWAP_END_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_LAST_INTENT_DATE", VALUEFUNC(_wrap_EventType_LAST_INTENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SINKING_FUND_CALL", VALUEFUNC(_wrap_EventType_SINKING_FUND_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_CALL", VALUEFUNC(_wrap_EventType_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_REQUIRED", VALUEFUNC(_wrap_TradeAllocIndicator_ALLOCATION_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT", VALUEFUNC(_wrap_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR", VALUEFUNC(_wrap_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE", VALUEFUNC(_wrap_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR", VALUEFUNC(_wrap_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_NOT_REQUIRED", VALUEFUNC(_wrap_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_NOT_LOGGED_IN", VALUEFUNC(_wrap_UserStatus_NOT_LOGGED_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_PASSWORD_INCORRECT", VALUEFUNC(_wrap_UserStatus_PASSWORD_INCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_LOGGED_IN", VALUEFUNC(_wrap_UserStatus_LOGGED_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE", VALUEFUNC(_wrap_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_USER_NOT_RECOGNISED", VALUEFUNC(_wrap_UserStatus_USER_NOT_RECOGNISED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_OTHER", VALUEFUNC(_wrap_UserStatus_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_PASSWORD_CHANGED", VALUEFUNC(_wrap_UserStatus_PASSWORD_CHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_SESSION_SHUTDOWN_WARNING", VALUEFUNC(_wrap_UserStatus_SESSION_SHUTDOWN_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_WEEKS", VALUEFUNC(_wrap_OrderDelayUnit_WEEKS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_TENTHS_OF_A_SECOND", VALUEFUNC(_wrap_OrderDelayUnit_TENTHS_OF_A_SECOND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_SECONDS", VALUEFUNC(_wrap_OrderDelayUnit_SECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MONTHS", VALUEFUNC(_wrap_OrderDelayUnit_MONTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_YEARS", VALUEFUNC(_wrap_OrderDelayUnit_YEARS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_NANOSECONDS", VALUEFUNC(_wrap_OrderDelayUnit_NANOSECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_HUNDREDTHS_OF_A_SECOND", VALUEFUNC(_wrap_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_HOURS", VALUEFUNC(_wrap_OrderDelayUnit_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MICROSECONDS", VALUEFUNC(_wrap_OrderDelayUnit_MICROSECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MINUTES", VALUEFUNC(_wrap_OrderDelayUnit_MINUTES_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MILLISECONDS", VALUEFUNC(_wrap_OrderDelayUnit_MILLISECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_DAYS", VALUEFUNC(_wrap_OrderDelayUnit_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradedFlatSwitch_NO", VALUEFUNC(_wrap_TradedFlatSwitch_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "TradedFlatSwitch_YES", VALUEFUNC(_wrap_TradedFlatSwitch_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRptStatus_ACCEPTED_WITH_ERRORS", VALUEFUNC(_wrap_TrdRptStatus_ACCEPTED_WITH_ERRORS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRptStatus_REJECTED", VALUEFUNC(_wrap_TrdRptStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRptStatus_ACCEPTED", VALUEFUNC(_wrap_TrdRptStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_PENDING", VALUEFUNC(_wrap_QuoteStatus_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_PENDING_END_TRADE", VALUEFUNC(_wrap_QuoteStatus_PENDING_END_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CROSS_MARKET_WARNING", VALUEFUNC(_wrap_QuoteStatus_CROSS_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED", VALUEFUNC(_wrap_QuoteStatus_CANCELED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_LOCKED_MARKET_WARNING", VALUEFUNC(_wrap_QuoteStatus_LOCKED_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_FOR_UNDERLYING", VALUEFUNC(_wrap_QuoteStatus_CANCELED_FOR_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT", VALUEFUNC(_wrap_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_TOO_LATE_TO_END", VALUEFUNC(_wrap_QuoteStatus_TOO_LATE_TO_END_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET", VALUEFUNC(_wrap_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET", VALUEFUNC(_wrap_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_FOR_SECURITY_TYPE", VALUEFUNC(_wrap_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_ALL", VALUEFUNC(_wrap_QuoteStatus_CANCELED_ALL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_PASS", VALUEFUNC(_wrap_QuoteStatus_PASS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_REJECTED", VALUEFUNC(_wrap_QuoteStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_QUERY", VALUEFUNC(_wrap_QuoteStatus_QUERY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_ACCEPTED", VALUEFUNC(_wrap_QuoteStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_EXPIRED", VALUEFUNC(_wrap_QuoteStatus_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_FOR_SYMBOL", VALUEFUNC(_wrap_QuoteStatus_CANCELED_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_REMOVED_FROM_MARKET", VALUEFUNC(_wrap_QuoteStatus_REMOVED_FROM_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_ACTIVE", VALUEFUNC(_wrap_QuoteStatus_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCEL_FOR_SYMBOL", VALUEFUNC(_wrap_QuoteStatus_CANCEL_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_QUOTE_NOT_FOUND", VALUEFUNC(_wrap_QuoteStatus_QUOTE_NOT_FOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SolicitedFlag_NO", VALUEFUNC(_wrap_SolicitedFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "SolicitedFlag_YES", VALUEFUNC(_wrap_SolicitedFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_DEALER_SOLD_SHORT", VALUEFUNC(_wrap_ShortSaleReason_DEALER_SOLD_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT", VALUEFUNC(_wrap_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT", VALUEFUNC(_wrap_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT", VALUEFUNC(_wrap_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE", VALUEFUNC(_wrap_ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT", VALUEFUNC(_wrap_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE", VALUEFUNC(_wrap_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK", VALUEFUNC(_wrap_PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MORE_AGGRESSIVE", VALUEFUNC(_wrap_PegRoundDirection_MORE_AGGRESSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MORE_PASSIVE", VALUEFUNC(_wrap_PegRoundDirection_MORE_PASSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK", VALUEFUNC(_wrap_PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "ModelType_PROPRIETARY", VALUEFUNC(_wrap_ModelType_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "ModelType_UTILITY_PROVIDED_STANDARD_MODEL", VALUEFUNC(_wrap_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get), 0);
  rb_define_singleton_method(mQuickfix, "FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT", VALUEFUNC(_wrap_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "FuturesValuationMethod_PREMIUM_STYLE", VALUEFUNC(_wrap_FuturesValuationMethod_PREMIUM_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET", VALUEFUNC(_wrap_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlMethod_CASH_SETTLEMENT_REQUIRED", VALUEFUNC(_wrap_SettlMethod_CASH_SETTLEMENT_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED", VALUEFUNC(_wrap_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_CONFIRMED", VALUEFUNC(_wrap_ConfirmStatus_CONFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS", VALUEFUNC(_wrap_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_REQUEST_REJECTED", VALUEFUNC(_wrap_ConfirmStatus_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_MISMATCHED_ACCOUNT", VALUEFUNC(_wrap_ConfirmStatus_MISMATCHED_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_RECEIVED", VALUEFUNC(_wrap_ConfirmStatus_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "LocateReqd_NO", VALUEFUNC(_wrap_LocateReqd_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LocateReqd_YES", VALUEFUNC(_wrap_LocateReqd_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "Adjustment_CANCEL", VALUEFUNC(_wrap_Adjustment_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "Adjustment_CORRECTION", VALUEFUNC(_wrap_Adjustment_CORRECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "Adjustment_ERROR", VALUEFUNC(_wrap_Adjustment_ERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnType_ASSIGNMENT", VALUEFUNC(_wrap_StreamAsgnType_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnType_TERMINATE_UNASSIGN", VALUEFUNC(_wrap_StreamAsgnType_TERMINATE_UNASSIGN_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnType_REJECTED", VALUEFUNC(_wrap_StreamAsgnType_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "LastRptRequested_NO", VALUEFUNC(_wrap_LastRptRequested_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LastRptRequested_YES", VALUEFUNC(_wrap_LastRptRequested_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_END_OF_DAY", VALUEFUNC(_wrap_SettlSessID_END_OF_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_ELECTRONIC_TRADING_HOURS", VALUEFUNC(_wrap_SettlSessID_ELECTRONIC_TRADING_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_REGULAR_TRADING_HOURS", VALUEFUNC(_wrap_SettlSessID_REGULAR_TRADING_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_INTRADAY", VALUEFUNC(_wrap_SettlSessID_INTRADAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_LOCKED_IN_TRADE_BREAK", VALUEFUNC(_wrap_TradeReportType_LOCKED_IN_TRADE_BREAK_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_NO_WAS", VALUEFUNC(_wrap_TradeReportType_NO_WAS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ADDENDUM", VALUEFUNC(_wrap_TradeReportType_ADDENDUM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_7", VALUEFUNC(_wrap_TradeReportType_7_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_PENDED", VALUEFUNC(_wrap_TradeReportType_PENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_DEFAULTED", VALUEFUNC(_wrap_TradeReportType_DEFAULTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_DECLINE", VALUEFUNC(_wrap_TradeReportType_DECLINE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_NEW", VALUEFUNC(_wrap_TradeReportType_ALLEGED_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_TRADE_REPORT_CANCEL", VALUEFUNC(_wrap_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_15", VALUEFUNC(_wrap_TradeReportType_ALLEGED_15_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_ADDENDUM", VALUEFUNC(_wrap_TradeReportType_ALLEGED_ADDENDUM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED", VALUEFUNC(_wrap_TradeReportType_ALLEGED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_SUBMIT", VALUEFUNC(_wrap_TradeReportType_SUBMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_1", VALUEFUNC(_wrap_TradeReportType_ALLEGED_1_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_INVALID_CMTA", VALUEFUNC(_wrap_TradeReportType_INVALID_CMTA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_NO_WAS", VALUEFUNC(_wrap_TradeReportType_ALLEGED_NO_WAS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_TRADE_REPORT_CANCEL", VALUEFUNC(_wrap_TradeReportType_TRADE_REPORT_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ACCEPT", VALUEFUNC(_wrap_TradeReportType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseStyle_AMERICAN", VALUEFUNC(_wrap_ExerciseStyle_AMERICAN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseStyle_EUROPEAN", VALUEFUNC(_wrap_ExerciseStyle_EUROPEAN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseStyle_BERMUDA", VALUEFUNC(_wrap_ExerciseStyle_BERMUDA_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ADDITIONAL_INFORMATION", VALUEFUNC(_wrap_HaltReasonChar_ADDITIONAL_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEW_PENDING", VALUEFUNC(_wrap_HaltReasonChar_NEW_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEWS_PENDING", VALUEFUNC(_wrap_HaltReasonChar_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ORDER_INFLUX", VALUEFUNC(_wrap_HaltReasonChar_ORDER_INFLUX_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEWS_DISSEMINATION", VALUEFUNC(_wrap_HaltReasonChar_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_EQUIPMENT_CHANGEOVER", VALUEFUNC(_wrap_HaltReasonChar_EQUIPMENT_CHANGEOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ORDER_IMBALANCE", VALUEFUNC(_wrap_HaltReasonChar_ORDER_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestination_POSIT", VALUEFUNC(_wrap_ExDestination_POSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestination_NONE", VALUEFUNC(_wrap_ExDestination_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY", VALUEFUNC(_wrap_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_WAREHOUSE_RECAP", VALUEFUNC(_wrap_AllocReportType_WAREHOUSE_RECAP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REJECT", VALUEFUNC(_wrap_AllocReportType_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_ACCEPT_PENDING", VALUEFUNC(_wrap_AllocReportType_ACCEPT_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_COMPLETE", VALUEFUNC(_wrap_AllocReportType_COMPLETE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REQUEST_TO_INTERMEDIARY", VALUEFUNC(_wrap_AllocReportType_REQUEST_TO_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY", VALUEFUNC(_wrap_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY", VALUEFUNC(_wrap_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REVERSE_PENDING", VALUEFUNC(_wrap_AllocReportType_REVERSE_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_ACCEPT", VALUEFUNC(_wrap_AllocReportType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY", VALUEFUNC(_wrap_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_INCOMPLETE_GROUP", VALUEFUNC(_wrap_AllocType_INCOMPLETE_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REVERSAL_PENDING", VALUEFUNC(_wrap_AllocType_REVERSAL_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_CALCULATED", VALUEFUNC(_wrap_AllocType_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REJECT", VALUEFUNC(_wrap_AllocType_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_PRELIMINARY", VALUEFUNC(_wrap_AllocType_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_ACCEPT_PENDING", VALUEFUNC(_wrap_AllocType_ACCEPT_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_CALCULATED", VALUEFUNC(_wrap_AllocType_BUYSIDE_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REQUEST_TO_INTERMEDIARY", VALUEFUNC(_wrap_AllocType_REQUEST_TO_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_READY_TO_BOOK_5", VALUEFUNC(_wrap_AllocType_BUYSIDE_READY_TO_BOOK_5_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_READY_TO_BOOK_6", VALUEFUNC(_wrap_AllocType_BUYSIDE_READY_TO_BOOK_6_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_COMPLETE_GROUP", VALUEFUNC(_wrap_AllocType_COMPLETE_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY", VALUEFUNC(_wrap_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_READY_TO_BOOK", VALUEFUNC(_wrap_AllocType_BUYSIDE_READY_TO_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_READY_TO_BOOK", VALUEFUNC(_wrap_AllocType_READY_TO_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_WAREHOUSE_INSTRUCTION", VALUEFUNC(_wrap_AllocType_WAREHOUSE_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_PRELIMINARY", VALUEFUNC(_wrap_AllocType_BUYSIDE_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_ACCEPT", VALUEFUNC(_wrap_AllocType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_INSUFFICIENT_CREDIT", VALUEFUNC(_wrap_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE", VALUEFUNC(_wrap_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_INVALID_PRICE", VALUEFUNC(_wrap_QuoteRequestRejectReason_INVALID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(_wrap_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY", VALUEFUNC(_wrap_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_EXCHANGE", VALUEFUNC(_wrap_QuoteRequestRejectReason_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT", VALUEFUNC(_wrap_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_UNKNOWN_SYMBOL", VALUEFUNC(_wrap_QuoteRequestRejectReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_OTHER", VALUEFUNC(_wrap_QuoteRequestRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_PASS", VALUEFUNC(_wrap_QuoteRequestRejectReason_PASS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NO_INVENTORY", VALUEFUNC(_wrap_QuoteRequestRejectReason_NO_INVENTORY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT", VALUEFUNC(_wrap_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_20_DAY_MOVING_AVERAGE", VALUEFUNC(_wrap_LiquidityIndType_20_DAY_MOVING_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_5_DAY_MOVING_AVERAGE", VALUEFUNC(_wrap_LiquidityIndType_5_DAY_MOVING_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_5DAY_MOVING_AVERAGE", VALUEFUNC(_wrap_LiquidityIndType_5DAY_MOVING_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_NORMAL_MARKET_SIZE", VALUEFUNC(_wrap_LiquidityIndType_NORMAL_MARKET_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_OTHER", VALUEFUNC(_wrap_LiquidityIndType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_IN_PROCESS", VALUEFUNC(_wrap_StatusValue_IN_PROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN", VALUEFUNC(_wrap_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOT_CONNECTED_2", VALUEFUNC(_wrap_StatusValue_NOT_CONNECTED_2_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP", VALUEFUNC(_wrap_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_CONNECTED", VALUEFUNC(_wrap_StatusValue_CONNECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOT_CONNECTED_3", VALUEFUNC(_wrap_StatusValue_NOT_CONNECTED_3_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_EXCHANGE_FOR_PHYSICAL_QTY", VALUEFUNC(_wrap_PosType_EXCHANGE_FOR_PHYSICAL_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSFER_TRADE_QTY", VALUEFUNC(_wrap_PosType_TRANSFER_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTER_SPREAD_QTY", VALUEFUNC(_wrap_PosType_INTER_SPREAD_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTRA_SPREAD_QTY", VALUEFUNC(_wrap_PosType_INTRA_SPREAD_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_START_OF_DAY_QTY", VALUEFUNC(_wrap_PosType_START_OF_DAY_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_DELIVERY_QTY", VALUEFUNC(_wrap_PosType_DELIVERY_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_PIT_TRADE_QTY", VALUEFUNC(_wrap_PosType_PIT_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTION_FROM_ASSIGNMENT", VALUEFUNC(_wrap_PosType_TRANSACTION_FROM_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTION_FROM_EXERCISE", VALUEFUNC(_wrap_PosType_TRANSACTION_FROM_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_OPTION_ASSIGNMENT", VALUEFUNC(_wrap_PosType_OPTION_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_AS_OF_TRADE_QTY", VALUEFUNC(_wrap_PosType_AS_OF_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ELECTRONIC_TRADE_QTY", VALUEFUNC(_wrap_PosType_ELECTRONIC_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_SUCCESSION_EVENT_ADJUSTMENT", VALUEFUNC(_wrap_PosType_SUCCESSION_EVENT_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_OPTION_EXERCISE_QTY", VALUEFUNC(_wrap_PosType_OPTION_EXERCISE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTION_QUANTITY", VALUEFUNC(_wrap_PosType_TRANSACTION_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_NET_DELTA_QTY", VALUEFUNC(_wrap_PosType_NET_DELTA_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_DELIVERY_NOTICE_QTY", VALUEFUNC(_wrap_PosType_DELIVERY_NOTICE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TOTAL_TRANSACTION_QTY", VALUEFUNC(_wrap_PosType_TOTAL_TRANSACTION_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ADJUSTMENT_QTY", VALUEFUNC(_wrap_PosType_ADJUSTMENT_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_END_OF_DAY_QTY", VALUEFUNC(_wrap_PosType_END_OF_DAY_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_RECEIVE_QUANTITY", VALUEFUNC(_wrap_PosType_RECEIVE_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CREDIT_EVENT_ADJUSTMENT", VALUEFUNC(_wrap_PosType_CREDIT_EVENT_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_PRIVATELY_NEGOTIATED_TRADE_QTY", VALUEFUNC(_wrap_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CORPORATE_ACTION_ADJUSTMENT", VALUEFUNC(_wrap_PosType_CORPORATE_ACTION_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CROSS_MARGIN_QTY", VALUEFUNC(_wrap_PosType_CROSS_MARGIN_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTEGRAL_SPLIT", VALUEFUNC(_wrap_PosType_INTEGRAL_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ALLOCATION_TRADE_QTY", VALUEFUNC(_wrap_PosType_ALLOCATION_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnAckType_ASSIGNMENT_REJECTED", VALUEFUNC(_wrap_StreamAsgnAckType_ASSIGNMENT_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnAckType_ASSIGNMENT_ACCEPTED", VALUEFUNC(_wrap_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_ABSOLUTE", VALUEFUNC(_wrap_MiscFeeBasis_ABSOLUTE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_PERCENTAGE", VALUEFUNC(_wrap_MiscFeeBasis_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_PER_UNIT", VALUEFUNC(_wrap_MiscFeeBasis_PER_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_MARKET", VALUEFUNC(_wrap_OrdType_FOREX_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_PREVIOUSLY_QUOTED", VALUEFUNC(_wrap_OrdType_FOREX_PREVIOUSLY_QUOTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUS_FUND_VALUATION_POINT", VALUEFUNC(_wrap_OrdType_PREVIOUS_FUND_VALUATION_POINT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PEGGED", VALUEFUNC(_wrap_OrdType_PEGGED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT_WITH_OR_WITHOUT", VALUEFUNC(_wrap_OrdType_LIMIT_WITH_OR_WITHOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_STOP_LIMIT", VALUEFUNC(_wrap_OrdType_STOP_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_SWAP", VALUEFUNC(_wrap_OrdType_FOREX_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT", VALUEFUNC(_wrap_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSLY_QUOTED", VALUEFUNC(_wrap_OrdType_PREVIOUSLY_QUOTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_COUNTER_ORDER_SELECTION", VALUEFUNC(_wrap_OrdType_COUNTER_ORDER_SELECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_IF_TOUCHED", VALUEFUNC(_wrap_OrdType_MARKET_IF_TOUCHED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_NEXT_FUND_VALUATION_POINT", VALUEFUNC(_wrap_OrdType_NEXT_FUND_VALUATION_POINT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_C", VALUEFUNC(_wrap_OrdType_FOREX_C_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_ON_CLOSE", VALUEFUNC(_wrap_OrdType_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_STOP", VALUEFUNC(_wrap_OrdType_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_LIMIT", VALUEFUNC(_wrap_OrdType_FOREX_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX", VALUEFUNC(_wrap_OrdType_FOREX_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FUNARI", VALUEFUNC(_wrap_OrdType_FUNARI_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_F", VALUEFUNC(_wrap_OrdType_FOREX_F_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSLY_INDICATED", VALUEFUNC(_wrap_OrdType_PREVIOUSLY_INDICATED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_WITH_OR_WITHOUT", VALUEFUNC(_wrap_OrdType_WITH_OR_WITHOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_ON_CLOSE", VALUEFUNC(_wrap_OrdType_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT", VALUEFUNC(_wrap_OrdType_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT", VALUEFUNC(_wrap_OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_G", VALUEFUNC(_wrap_OrdType_FOREX_G_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT_ON_CLOSE", VALUEFUNC(_wrap_OrdType_LIMIT_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_H", VALUEFUNC(_wrap_OrdType_FOREX_H_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_ON_BASIS", VALUEFUNC(_wrap_OrdType_ON_BASIS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT_OR_BETTER", VALUEFUNC(_wrap_OrdType_LIMIT_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET", VALUEFUNC(_wrap_OrdType_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS", VALUEFUNC(_wrap_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NON_ACT", VALUEFUNC(_wrap_MatchType_NON_ACT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_AUTO_MATCH", VALUEFUNC(_wrap_MatchType_AUTO_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CALL_AUCTION", VALUEFUNC(_wrap_MatchType_CALL_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST", VALUEFUNC(_wrap_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_M2_MATCH", VALUEFUNC(_wrap_MatchType_ACT_M2_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ONE_PARTY_TRADE_REPORT", VALUEFUNC(_wrap_MatchType_ONE_PARTY_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_M1_MATCH", VALUEFUNC(_wrap_MatchType_ACT_M1_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COUNTER_ORDER_SELECTION", VALUEFUNC(_wrap_MatchType_COUNTER_ORDER_SELECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ISSUING_BUY_BACK_AUCTION", VALUEFUNC(_wrap_MatchType_ISSUING_BUY_BACK_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT", VALUEFUNC(_wrap_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CROSS_AUCTION_63", VALUEFUNC(_wrap_MatchType_CROSS_AUCTION_63_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CROSS_AUCTION_5", VALUEFUNC(_wrap_MatchType_CROSS_AUCTION_5_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CALL_AUCTION_7", VALUEFUNC(_wrap_MatchType_CALL_AUCTION_7_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COUNTER_ORDER_SELECTION_64", VALUEFUNC(_wrap_MatchType_COUNTER_ORDER_SELECTION_64_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_TWO_PARTY_TRADE_REPORT", VALUEFUNC(_wrap_MatchType_TWO_PARTY_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_DEFAULT_TRADE", VALUEFUNC(_wrap_MatchType_ACT_DEFAULT_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_ACCEPTED_TRADE", VALUEFUNC(_wrap_MatchType_ACT_ACCEPTED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COUNTER_ORDER_SELECTION_6", VALUEFUNC(_wrap_MatchType_COUNTER_ORDER_SELECTION_6_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CROSS_AUCTION", VALUEFUNC(_wrap_MatchType_CROSS_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CALL_AUCTION_65", VALUEFUNC(_wrap_MatchType_CALL_AUCTION_65_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CONFIRMED_TRADE_REPORT", VALUEFUNC(_wrap_MatchType_CONFIRMED_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_M6_MATCH", VALUEFUNC(_wrap_MatchType_ACT_M6_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT", VALUEFUNC(_wrap_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CONTINUOUS_AUTO_MATCH", VALUEFUNC(_wrap_MatchType_CONTINUOUS_AUTO_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_OCS_LOCKED_IN_NON_ACT", VALUEFUNC(_wrap_MatchType_OCS_LOCKED_IN_NON_ACT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH", VALUEFUNC(_wrap_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2", VALUEFUNC(_wrap_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_DEFAULT_AFTER_M2", VALUEFUNC(_wrap_MatchType_ACT_DEFAULT_AFTER_M2_get), 0);
  rb_define_singleton_method(mQuickfix, "OptPayoutType_BINARY", VALUEFUNC(_wrap_OptPayoutType_BINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "OptPayoutType_VANILLA", VALUEFUNC(_wrap_OptPayoutType_VANILLA_get), 0);
  rb_define_singleton_method(mQuickfix, "OptPayoutType_CAPPED", VALUEFUNC(_wrap_OptPayoutType_CAPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "MarketUpdateAction_DELETE", VALUEFUNC(_wrap_MarketUpdateAction_DELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "MarketUpdateAction_ADD", VALUEFUNC(_wrap_MarketUpdateAction_ADD_get), 0);
  rb_define_singleton_method(mQuickfix, "MarketUpdateAction_MODIFY", VALUEFUNC(_wrap_MarketUpdateAction_MODIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION", VALUEFUNC(_wrap_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT", VALUEFUNC(_wrap_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNKNOWN_DEAL", VALUEFUNC(_wrap_CollAsgnRejectReason_UNKNOWN_DEAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL", VALUEFUNC(_wrap_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_OTHER", VALUEFUNC(_wrap_CollAsgnRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION", VALUEFUNC(_wrap_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_INSUFFICIENT_COLLATERAL", VALUEFUNC(_wrap_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "IndividualAllocType_SUB_ALLOCATE", VALUEFUNC(_wrap_IndividualAllocType_SUB_ALLOCATE_get), 0);
  rb_define_singleton_method(mQuickfix, "IndividualAllocType_THIRD_PARTY_ALLOCATION", VALUEFUNC(_wrap_IndividualAllocType_THIRD_PARTY_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION", VALUEFUNC(_wrap_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE", VALUEFUNC(_wrap_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES", VALUEFUNC(_wrap_GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE", VALUEFUNC(_wrap_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES", VALUEFUNC(_wrap_GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_get), 0);
  rb_define_singleton_method(mQuickfix, "PutOrCall_PUT", VALUEFUNC(_wrap_PutOrCall_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "PutOrCall_CALL", VALUEFUNC(_wrap_PutOrCall_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "FundRenewWaiv_NO", VALUEFUNC(_wrap_FundRenewWaiv_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "FundRenewWaiv_YES", VALUEFUNC(_wrap_FundRenewWaiv_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ForexReq_NO", VALUEFUNC(_wrap_ForexReq_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ForexReq_YES", VALUEFUNC(_wrap_ForexReq_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_TRADED_AS_A_SPREAD_LEG", VALUEFUNC(_wrap_TickRuleType_TRADED_AS_A_SPREAD_LEG_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_REGULAR", VALUEFUNC(_wrap_TickRuleType_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_VARIABLE", VALUEFUNC(_wrap_TickRuleType_VARIABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_SETTLED_AS_A_SPREAD_LEG", VALUEFUNC(_wrap_TickRuleType_SETTLED_AS_A_SPREAD_LEG_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_FIXED", VALUEFUNC(_wrap_TickRuleType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_PRICE", VALUEFUNC(_wrap_DiscretionOffsetType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_PRICE_TIER", VALUEFUNC(_wrap_DiscretionOffsetType_PRICE_TIER_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_TICKS", VALUEFUNC(_wrap_DiscretionOffsetType_TICKS_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_BASIS_POINTS", VALUEFUNC(_wrap_DiscretionOffsetType_BASIS_POINTS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmTransType_REPLACE", VALUEFUNC(_wrap_ConfirmTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmTransType_NEW", VALUEFUNC(_wrap_ConfirmTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmTransType_CANCEL", VALUEFUNC(_wrap_ConfirmTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "MDSecSizeType_CUSTOMER", VALUEFUNC(_wrap_MDSecSizeType_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_CHANGE_OF_TRADING_STATUS", VALUEFUNC(_wrap_TradSesEvent_CHANGE_OF_TRADING_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_CHANGE_OF_TRADING_SESSION", VALUEFUNC(_wrap_TradSesEvent_CHANGE_OF_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_CHANGE_OF_TRADING_SUBSESSION", VALUEFUNC(_wrap_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_TRADING_RESUMES", VALUEFUNC(_wrap_TradSesEvent_TRADING_RESUMES_get), 0);
  rb_define_singleton_method(mQuickfix, "DlvyInstType_SECURITIES", VALUEFUNC(_wrap_DlvyInstType_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "DlvyInstType_CASH", VALUEFUNC(_wrap_DlvyInstType_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMPLIED_TRADE", VALUEFUNC(_wrap_TradeCondition_IMPLIED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENING_PRICE", VALUEFUNC(_wrap_TradeCondition_OPENING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_PRIOR_REFERENCE_PRICE", VALUEFUNC(_wrap_TradeCondition_PRIOR_REFERENCE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_LAST_ETH", VALUEFUNC(_wrap_TradeCondition_CANCEL_LAST_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SELLER", VALUEFUNC(_wrap_TradeCondition_SELLER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_DISTRIBUTION", VALUEFUNC(_wrap_TradeCondition_DISTRIBUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_NEXT_DAY_TRADE", VALUEFUNC(_wrap_TradeCondition_NEXT_DAY_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STRADDLE_ETH", VALUEFUNC(_wrap_TradeCondition_STRADDLE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SPREAD", VALUEFUNC(_wrap_TradeCondition_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CROSSED_AO", VALUEFUNC(_wrap_TradeCondition_CROSSED_AO_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD_LAST_SALE", VALUEFUNC(_wrap_TradeCondition_SOLD_LAST_SALE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENED_SALE_ETH", VALUEFUNC(_wrap_TradeCondition_OPENED_SALE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_REOPEN_ETH", VALUEFUNC(_wrap_TradeCondition_REOPEN_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD_LAST_SALE_ETH", VALUEFUNC(_wrap_TradeCondition_SOLD_LAST_SALE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_SOLD_LAST", VALUEFUNC(_wrap_TradeCondition_STOPPED_SOLD_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP", VALUEFUNC(_wrap_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_FORM_T", VALUEFUNC(_wrap_TradeCondition_FORM_T_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_ADJUSTED", VALUEFUNC(_wrap_TradeCondition_ADJUSTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_ETH", VALUEFUNC(_wrap_TradeCondition_CANCEL_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OUT_OF_SEQUENCE_ETH", VALUEFUNC(_wrap_TradeCondition_OUT_OF_SEQUENCE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_COMBO_ETH", VALUEFUNC(_wrap_TradeCondition_COMBO_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_ONLY_ETH", VALUEFUNC(_wrap_TradeCondition_CANCEL_ONLY_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STRADDLE", VALUEFUNC(_wrap_TradeCondition_STRADDLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OUTSIDE_SPREAD", VALUEFUNC(_wrap_TradeCondition_OUTSIDE_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BUNCHED_SALE", VALUEFUNC(_wrap_TradeCondition_BUNCHED_SALE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_STOPPED", VALUEFUNC(_wrap_TradeCondition_CANCEL_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_LATE_OPEN_ETH", VALUEFUNC(_wrap_TradeCondition_LATE_OPEN_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENING_REOPENING_TRADE_DETAIL", VALUEFUNC(_wrap_TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL", VALUEFUNC(_wrap_TradeCondition_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_COMBO", VALUEFUNC(_wrap_TradeCondition_COMBO_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENING", VALUEFUNC(_wrap_TradeCondition_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_ACQUISITION", VALUEFUNC(_wrap_TradeCondition_ACQUISITION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENED", VALUEFUNC(_wrap_TradeCondition_OPENED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_ONLY", VALUEFUNC(_wrap_TradeCondition_CANCEL_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_NEXT_DAY", VALUEFUNC(_wrap_TradeCondition_NEXT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BARGAIN_CONDITION", VALUEFUNC(_wrap_TradeCondition_BARGAIN_CONDITION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED", VALUEFUNC(_wrap_TradeCondition_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CONVERTED_PRICE_INDICATOR", VALUEFUNC(_wrap_TradeCondition_CONVERTED_PRICE_INDICATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OFFICIAL_CLOSING_PRICE", VALUEFUNC(_wrap_TradeCondition_OFFICIAL_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_ADJUSTED_ETH", VALUEFUNC(_wrap_TradeCondition_ADJUSTED_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_RULE_155_TRADE", VALUEFUNC(_wrap_TradeCondition_RULE_155_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AUTOMATIC_EXECUTION", VALUEFUNC(_wrap_TradeCondition_AUTOMATIC_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CROSSED_X", VALUEFUNC(_wrap_TradeCondition_CROSSED_X_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AUTO_EXECUTION_ETH", VALUEFUNC(_wrap_TradeCondition_AUTO_EXECUTION_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_MULTILEG_TO_MULTILEG_TRADE", VALUEFUNC(_wrap_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BASKET_INDEX", VALUEFUNC(_wrap_TradeCondition_BASKET_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE", VALUEFUNC(_wrap_TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_FINAL_PRICE_OF_SESSION", VALUEFUNC(_wrap_TradeCondition_FINAL_PRICE_OF_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_STOCK", VALUEFUNC(_wrap_TradeCondition_STOPPED_STOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OFFICAL_CLOSING_PRICE", VALUEFUNC(_wrap_TradeCondition_OFFICAL_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE", VALUEFUNC(_wrap_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CASH", VALUEFUNC(_wrap_TradeCondition_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_OPEN", VALUEFUNC(_wrap_TradeCondition_CANCEL_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_REGULAR_ETH", VALUEFUNC(_wrap_TradeCondition_REGULAR_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_ETH", VALUEFUNC(_wrap_TradeCondition_STOPPED_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_VOLUME_ONLY", VALUEFUNC(_wrap_TradeCondition_VOLUME_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_STOPPED_ETH", VALUEFUNC(_wrap_TradeCondition_CANCEL_STOPPED_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_OUT_OF_SEQUENCE", VALUEFUNC(_wrap_TradeCondition_STOPPED_OUT_OF_SEQUENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CASH_TRADE", VALUEFUNC(_wrap_TradeCondition_CASH_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SPLIT_TRADE", VALUEFUNC(_wrap_TradeCondition_SPLIT_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMBALANCE_MORE_BUYERS", VALUEFUNC(_wrap_TradeCondition_IMBALANCE_MORE_BUYERS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMBALANCE_MORE_SELLERS", VALUEFUNC(_wrap_TradeCondition_IMBALANCE_MORE_SELLERS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_INTRADAY_TRADE_DETAIL", VALUEFUNC(_wrap_TradeCondition_INTRADAY_TRADE_DETAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_RULE_127_TRADE", VALUEFUNC(_wrap_TradeCondition_RULE_127_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BUNCHED", VALUEFUNC(_wrap_TradeCondition_BUNCHED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_REOPEN", VALUEFUNC(_wrap_TradeCondition_REOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_EX_PIT", VALUEFUNC(_wrap_TradeCondition_EX_PIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_DIRECT_PLUS", VALUEFUNC(_wrap_TradeCondition_DIRECT_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_LAST", VALUEFUNC(_wrap_TradeCondition_CANCEL_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AVERAGE_PRICE_TRADE", VALUEFUNC(_wrap_TradeCondition_AVERAGE_PRICE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD_LAST", VALUEFUNC(_wrap_TradeCondition_SOLD_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_MARKETPLACE_ENTERED_TRADE", VALUEFUNC(_wrap_TradeCondition_MARKETPLACE_ENTERED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SPREAD_ETH", VALUEFUNC(_wrap_TradeCondition_SPREAD_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_OPEN_ETH", VALUEFUNC(_wrap_TradeCondition_CANCEL_OPEN_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_EXCHANGE_LAST", VALUEFUNC(_wrap_TradeCondition_EXCHANGE_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_FAST_MARKET", VALUEFUNC(_wrap_TradeCondition_FAST_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BURST_BASKET", VALUEFUNC(_wrap_TradeCondition_BURST_BASKET_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD", VALUEFUNC(_wrap_TradeCondition_SOLD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceLimitType_PRICE", VALUEFUNC(_wrap_PriceLimitType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceLimitType_TICKS", VALUEFUNC(_wrap_PriceLimitType_TICKS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceLimitType_PERCENTAGE", VALUEFUNC(_wrap_PriceLimitType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PER_SHARE", VALUEFUNC(_wrap_CommType_PER_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER", VALUEFUNC(_wrap_CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_ABSOLUTE", VALUEFUNC(_wrap_CommType_ABSOLUTE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PER_BOND", VALUEFUNC(_wrap_CommType_PER_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENTAGE", VALUEFUNC(_wrap_CommType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENTAGE_WAIVED_4", VALUEFUNC(_wrap_CommType_PERCENTAGE_WAIVED_4_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_POINTS_PER_BOND_OR_CONTRACT", VALUEFUNC(_wrap_CommType_POINTS_PER_BOND_OR_CONTRACT_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENTAGE_WAIVED_5", VALUEFUNC(_wrap_CommType_PERCENTAGE_WAIVED_5_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PER_UNIT", VALUEFUNC(_wrap_CommType_PER_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENT", VALUEFUNC(_wrap_CommType_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_4", VALUEFUNC(_wrap_CommType_4_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_5", VALUEFUNC(_wrap_CommType_5_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_OTHER", VALUEFUNC(_wrap_RegistRejReasonCode_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS", VALUEFUNC(_wrap_RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_BANKRUPT", VALUEFUNC(_wrap_FinancialStatus_BANKRUPT_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_RESTRICTED", VALUEFUNC(_wrap_FinancialStatus_RESTRICTED_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_PENDING_DELISTING", VALUEFUNC(_wrap_FinancialStatus_PENDING_DELISTING_get), 0);
  rb_define_singleton_method(mQuickfix, "LastFragment_NO", VALUEFUNC(_wrap_LastFragment_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LastFragment_YES", VALUEFUNC(_wrap_LastFragment_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "NotifyBrokerOfCredit_NO", VALUEFUNC(_wrap_NotifyBrokerOfCredit_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "NotifyBrokerOfCredit_YES", VALUEFUNC(_wrap_NotifyBrokerOfCredit_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_DEPARTMENT", VALUEFUNC(_wrap_PartySubIDType_DEPARTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FAX_NUMBER", VALUEFUNC(_wrap_PartySubIDType_FAX_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CASH_ACCOUNT_NUMBER", VALUEFUNC(_wrap_PartySubIDType_CASH_ACCOUNT_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTERED_ADDRESS_12", VALUEFUNC(_wrap_PartySubIDType_REGISTERED_ADDRESS_12_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CONTACT_NAME", VALUEFUNC(_wrap_PartySubIDType_CONTACT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PERSON", VALUEFUNC(_wrap_PartySubIDType_PERSON_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FIRM", VALUEFUNC(_wrap_PartySubIDType_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITY_LOCATE_ID", VALUEFUNC(_wrap_PartySubIDType_SECURITY_LOCATE_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_POSITION_ACCOUNT_TYPE", VALUEFUNC(_wrap_PartySubIDType_POSITION_ACCOUNT_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CASH_ACCOUNT_NAME", VALUEFUNC(_wrap_PartySubIDType_CASH_ACCOUNT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_POSTAL_ADDRESS", VALUEFUNC(_wrap_PartySubIDType_POSTAL_ADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PROFESSIONAL_CLIENT", VALUEFUNC(_wrap_PartySubIDType_PROFESSIONAL_CLIENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_LOCATION", VALUEFUNC(_wrap_PartySubIDType_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FUND_ACCOUNT_NAME", VALUEFUNC(_wrap_PartySubIDType_FUND_ACCOUNT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTRATION_NUMBER", VALUEFUNC(_wrap_PartySubIDType_REGISTRATION_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SYSTEM", VALUEFUNC(_wrap_PartySubIDType_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE", VALUEFUNC(_wrap_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGULATORY_STATUS", VALUEFUNC(_wrap_PartySubIDType_REGULATORY_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER", VALUEFUNC(_wrap_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_TELEX_NUMBER", VALUEFUNC(_wrap_PartySubIDType_TELEX_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTERED_ADDRESS_18", VALUEFUNC(_wrap_PartySubIDType_REGISTERED_ADDRESS_18_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_BIC", VALUEFUNC(_wrap_PartySubIDType_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTRATION_NAME", VALUEFUNC(_wrap_PartySubIDType_REGISTRATION_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_EMAIL_ADDRESS", VALUEFUNC(_wrap_PartySubIDType_EMAIL_ADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_LOCATION_DESK", VALUEFUNC(_wrap_PartySubIDType_LOCATION_DESK_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_APPLICATION", VALUEFUNC(_wrap_PartySubIDType_APPLICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITIES_ACCOUNT_NAME", VALUEFUNC(_wrap_PartySubIDType_SECURITIES_ACCOUNT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PHONE_NUMBER", VALUEFUNC(_wrap_PartySubIDType_PHONE_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_ELIGIBLE_COUNTERPARTY", VALUEFUNC(_wrap_PartySubIDType_ELIGIBLE_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_MARKET_MAKER", VALUEFUNC(_wrap_PartySubIDType_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_EXECUTION_VENUE", VALUEFUNC(_wrap_PartySubIDType_EXECUTION_VENUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITIES_ACCOUNT_NUMBER", VALUEFUNC(_wrap_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FULL_LEGAL_NAME_OF_FIRM", VALUEFUNC(_wrap_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocNoOrdersType_EXPLICIT_LIST_PROVIDED", VALUEFUNC(_wrap_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocNoOrdersType_NOT_SPECIFIED", VALUEFUNC(_wrap_AllocNoOrdersType_NOT_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_FX_SWAP", VALUEFUNC(_wrap_AllocLinkType_FX_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_F_X_NETTING", VALUEFUNC(_wrap_AllocLinkType_F_X_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_FX_NETTING", VALUEFUNC(_wrap_AllocLinkType_FX_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_F_X_SWAP", VALUEFUNC(_wrap_AllocLinkType_F_X_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingSettlementType_T_PLUS_1", VALUEFUNC(_wrap_UnderlyingSettlementType_T_PLUS_1_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingSettlementType_T_PLUS_3", VALUEFUNC(_wrap_UnderlyingSettlementType_T_PLUS_3_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingSettlementType_T_PLUS_4", VALUEFUNC(_wrap_UnderlyingSettlementType_T_PLUS_4_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_NEW", VALUEFUNC(_wrap_DisplayMethod_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_UNDISCLOSED", VALUEFUNC(_wrap_DisplayMethod_UNDISCLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_RANDOM", VALUEFUNC(_wrap_DisplayMethod_RANDOM_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_INITIAL", VALUEFUNC(_wrap_DisplayMethod_INITIAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_PARTIALLY_ASSIGNED", VALUEFUNC(_wrap_CollStatus_PARTIALLY_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_ASSIGNMENT_PROPOSED", VALUEFUNC(_wrap_CollStatus_ASSIGNMENT_PROPOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_CHALLENGED", VALUEFUNC(_wrap_CollStatus_CHALLENGED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_ASSIGNED", VALUEFUNC(_wrap_CollStatus_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_UNASSIGNED", VALUEFUNC(_wrap_CollStatus_UNASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDEVALUE_2", VALUEFUNC(_wrap_SideValueInd_SIDEVALUE_2_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDEVALUE1", VALUEFUNC(_wrap_SideValueInd_SIDEVALUE1_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDE_VALUE_1", VALUEFUNC(_wrap_SideValueInd_SIDE_VALUE_1_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDE_VALUE_2", VALUEFUNC(_wrap_SideValueInd_SIDE_VALUE_2_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgDirection_RECEIVE", VALUEFUNC(_wrap_MsgDirection_RECEIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgDirection_SEND", VALUEFUNC(_wrap_MsgDirection_SEND_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_DELETE", VALUEFUNC(_wrap_MDUpdateAction_DELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_NEW", VALUEFUNC(_wrap_MDUpdateAction_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_DELETE_THRU", VALUEFUNC(_wrap_MDUpdateAction_DELETE_THRU_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_DELETE_FROM", VALUEFUNC(_wrap_MDUpdateAction_DELETE_FROM_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_OVERLAY", VALUEFUNC(_wrap_MDUpdateAction_OVERLAY_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_CHANGE", VALUEFUNC(_wrap_MDUpdateAction_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED", VALUEFUNC(_wrap_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_COMPARED_MATCHED_OR_AFFIRMED", VALUEFUNC(_wrap_MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_ADVISORY_OR_ALERT", VALUEFUNC(_wrap_MatchStatus_ADVISORY_OR_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED", VALUEFUNC(_wrap_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_REUTERS", VALUEFUNC(_wrap_RateSource_REUTERS_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_OTHER", VALUEFUNC(_wrap_RateSource_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_BLOOMBERG", VALUEFUNC(_wrap_RateSource_BLOOMBERG_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_TELERATE", VALUEFUNC(_wrap_RateSource_TELERATE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_CLOSE", VALUEFUNC(_wrap_AllocPositionEffect_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_FIFO", VALUEFUNC(_wrap_AllocPositionEffect_FIFO_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_OPEN", VALUEFUNC(_wrap_AllocPositionEffect_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_ROLLED", VALUEFUNC(_wrap_AllocPositionEffect_ROLLED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER", VALUEFUNC(_wrap_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_PROPRIETARY", VALUEFUNC(_wrap_PartyIDSource_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER", VALUEFUNC(_wrap_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER", VALUEFUNC(_wrap_PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER", VALUEFUNC(_wrap_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER", VALUEFUNC(_wrap_PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_TRADING_ACCOUNT", VALUEFUNC(_wrap_PartyIDSource_TAIWANESE_TRADING_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_TRADING_ACCT", VALUEFUNC(_wrap_PartyIDSource_TAIWANESE_TRADING_ACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY", VALUEFUNC(_wrap_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_US_SOCIAL_SECURITY_NUMBER", VALUEFUNC(_wrap_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER", VALUEFUNC(_wrap_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE", VALUEFUNC(_wrap_PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT", VALUEFUNC(_wrap_PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII", VALUEFUNC(_wrap_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_SETTLEMENT_ENTITY_LOCATION", VALUEFUNC(_wrap_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_PROPRIETARY_CUSTOM_CODE", VALUEFUNC(_wrap_PartyIDSource_PROPRIETARY_CUSTOM_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_BIC", VALUEFUNC(_wrap_PartyIDSource_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CHINESE_INVESTOR_ID", VALUEFUNC(_wrap_PartyIDSource_CHINESE_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_MIC", VALUEFUNC(_wrap_PartyIDSource_MIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_KOREAN_INVESTOR_ID", VALUEFUNC(_wrap_PartyIDSource_KOREAN_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_ISO_COUNTRY_CODE", VALUEFUNC(_wrap_PartyIDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID", VALUEFUNC(_wrap_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CHINESE_B_SHARE", VALUEFUNC(_wrap_PartyIDSource_CHINESE_B_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExchangeForPhysical_NO", VALUEFUNC(_wrap_ExchangeForPhysical_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ExchangeForPhysical_YES", VALUEFUNC(_wrap_ExchangeForPhysical_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS", VALUEFUNC(_wrap_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_TRADING_SESSION", VALUEFUNC(_wrap_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS", VALUEFUNC(_wrap_SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION", VALUEFUNC(_wrap_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_BOOK_TYPE", VALUEFUNC(_wrap_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION", VALUEFUNC(_wrap_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH", VALUEFUNC(_wrap_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_TRADING_RESUMES", VALUEFUNC(_wrap_SecurityTradingEvent_TRADING_RESUMES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED", VALUEFUNC(_wrap_SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAction_ADD", VALUEFUNC(_wrap_CollAction_ADD_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAction_REMOVE", VALUEFUNC(_wrap_CollAction_REMOVE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAction_RETAIN", VALUEFUNC(_wrap_CollAction_RETAIN_get), 0);
  rb_define_singleton_method(mQuickfix, "PossDupFlag_NO", VALUEFUNC(_wrap_PossDupFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PossDupFlag_YES", VALUEFUNC(_wrap_PossDupFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ALL_DONE", VALUEFUNC(_wrap_ListStatusType_ALL_DONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_TIMED", VALUEFUNC(_wrap_ListStatusType_TIMED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_EXECSTARTED", VALUEFUNC(_wrap_ListStatusType_EXECSTARTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_RESPONSE", VALUEFUNC(_wrap_ListStatusType_RESPONSE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ALLDONE", VALUEFUNC(_wrap_ListStatusType_ALLDONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ALERT", VALUEFUNC(_wrap_ListStatusType_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ACK", VALUEFUNC(_wrap_ListStatusType_ACK_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_EXEC_STARTED", VALUEFUNC(_wrap_ListStatusType_EXEC_STARTED_get), 0);
  rb_define_singleton_method(mQuickfix, "GapFillFlag_NO", VALUEFUNC(_wrap_GapFillFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "GapFillFlag_YES", VALUEFUNC(_wrap_GapFillFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING", VALUEFUNC(_wrap_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_TWO_PARTY_REPORT", VALUEFUNC(_wrap_TradeHandlingInstr_TWO_PARTY_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING", VALUEFUNC(_wrap_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_TRADE_CONFIRMATION", VALUEFUNC(_wrap_TradeHandlingInstr_TRADE_CONFIRMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH", VALUEFUNC(_wrap_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM", VALUEFUNC(_wrap_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_ELECTRONIC", VALUEFUNC(_wrap_TradSesMethod_ELECTRONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_TWO_PARTY", VALUEFUNC(_wrap_TradSesMethod_TWO_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_OPEN_OUTCRY", VALUEFUNC(_wrap_TradSesMethod_OPEN_OUTCRY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_AGENCY", VALUEFUNC(_wrap_TradeType_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_VWAP_GUARANTEE", VALUEFUNC(_wrap_TradeType_VWAP_GUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_RISK_TRADE", VALUEFUNC(_wrap_TradeType_RISK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_GUARANTEED_CLOSE", VALUEFUNC(_wrap_TradeType_GUARANTEED_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventCondition_AND", VALUEFUNC(_wrap_ComplexEventCondition_AND_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventCondition_OR", VALUEFUNC(_wrap_ComplexEventCondition_OR_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_SONIA", VALUEFUNC(_wrap_BenchmarkCurveName_SONIA_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_MUNIAAA", VALUEFUNC(_wrap_BenchmarkCurveName_MUNIAAA_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_LIBID", VALUEFUNC(_wrap_BenchmarkCurveName_LIBID_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_PFANDBRIEFE", VALUEFUNC(_wrap_BenchmarkCurveName_PFANDBRIEFE_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_EUREPO", VALUEFUNC(_wrap_BenchmarkCurveName_EUREPO_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_FUTURESWAP", VALUEFUNC(_wrap_BenchmarkCurveName_FUTURESWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_TREASURY", VALUEFUNC(_wrap_BenchmarkCurveName_TREASURY_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_OTHER", VALUEFUNC(_wrap_BenchmarkCurveName_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_EURIBOR", VALUEFUNC(_wrap_BenchmarkCurveName_EURIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_EONIA", VALUEFUNC(_wrap_BenchmarkCurveName_EONIA_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_LIBOR", VALUEFUNC(_wrap_BenchmarkCurveName_LIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_SWAP", VALUEFUNC(_wrap_BenchmarkCurveName_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_MARGIN_CLOSE", VALUEFUNC(_wrap_CashMargin_MARGIN_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_MARGIN_OPEN", VALUEFUNC(_wrap_CashMargin_MARGIN_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_CASH", VALUEFUNC(_wrap_CashMargin_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_REPLACE", VALUEFUNC(_wrap_SettlObligTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_NEW", VALUEFUNC(_wrap_SettlObligTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_RESTATE", VALUEFUNC(_wrap_SettlObligTransType_RESTATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_CANCEL", VALUEFUNC(_wrap_SettlObligTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_PEGGED", VALUEFUNC(_wrap_DeskOrderHandlingInst_PEGGED_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_ON_OPEN", VALUEFUNC(_wrap_DeskOrderHandlingInst_MARKET_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_SCALE", VALUEFUNC(_wrap_DeskOrderHandlingInst_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_FILL_OR_KILL", VALUEFUNC(_wrap_DeskOrderHandlingInst_FILL_OR_KILL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_ALL_OR_NONE", VALUEFUNC(_wrap_DeskOrderHandlingInst_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_NOT_HELD", VALUEFUNC(_wrap_DeskOrderHandlingInst_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_DIRECTED_ORDER", VALUEFUNC(_wrap_DeskOrderHandlingInst_DIRECTED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_STOP_STOCK_TRANSACTION", VALUEFUNC(_wrap_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_OVER_THE_DAY", VALUEFUNC(_wrap_DeskOrderHandlingInst_OVER_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_ADD_ON_ORDER", VALUEFUNC(_wrap_DeskOrderHandlingInst_ADD_ON_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_AT_CLOSE", VALUEFUNC(_wrap_DeskOrderHandlingInst_MARKET_AT_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_LIMIT_ON_OPEN", VALUEFUNC(_wrap_DeskOrderHandlingInst_LIMIT_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_CASH_NOT_HELD", VALUEFUNC(_wrap_DeskOrderHandlingInst_CASH_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_ON_CLOSE", VALUEFUNC(_wrap_DeskOrderHandlingInst_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_TIME_ORDER", VALUEFUNC(_wrap_DeskOrderHandlingInst_TIME_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_LIMIT_ON_CLOSE", VALUEFUNC(_wrap_DeskOrderHandlingInst_LIMIT_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL", VALUEFUNC(_wrap_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_TRAILING_STOP", VALUEFUNC(_wrap_DeskOrderHandlingInst_TRAILING_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_WORK", VALUEFUNC(_wrap_DeskOrderHandlingInst_WORK_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_RESERVE_SIZE_ORDER", VALUEFUNC(_wrap_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MINIMUM_QUANTITY", VALUEFUNC(_wrap_DeskOrderHandlingInst_MINIMUM_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_AT_OPEN", VALUEFUNC(_wrap_DeskOrderHandlingInst_MARKET_AT_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_IMBALANCE_ONLY", VALUEFUNC(_wrap_DeskOrderHandlingInst_IMBALANCE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION", VALUEFUNC(_wrap_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION", VALUEFUNC(_wrap_PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_DO_NOT_EXERCISE", VALUEFUNC(_wrap_PosTransType_DO_NOT_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_LARGE_TRADER_SUBMISSION", VALUEFUNC(_wrap_PosTransType_LARGE_TRADER_SUBMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_EXERCISE", VALUEFUNC(_wrap_PosTransType_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_PLEDGE", VALUEFUNC(_wrap_PosTransType_PLEDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_POSITION_ADJUSTMENT", VALUEFUNC(_wrap_PosTransType_POSITION_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "Seniority_SUBORDINATED", VALUEFUNC(_wrap_Seniority_SUBORDINATED_get), 0);
  rb_define_singleton_method(mQuickfix, "Seniority_SENIOR_SECURED", VALUEFUNC(_wrap_Seniority_SENIOR_SECURED_get), 0);
  rb_define_singleton_method(mQuickfix, "Seniority_SENIOR", VALUEFUNC(_wrap_Seniority_SENIOR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlCurrFxRateCalc_DIVIDE", VALUEFUNC(_wrap_SettlCurrFxRateCalc_DIVIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlCurrFxRateCalc_MULTIPLY", VALUEFUNC(_wrap_SettlCurrFxRateCalc_MULTIPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_COMPLETED", VALUEFUNC(_wrap_PosMaintStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_ACCEPTED_WITH_WARNINGS", VALUEFUNC(_wrap_PosMaintStatus_ACCEPTED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_REJECTED", VALUEFUNC(_wrap_PosMaintStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_ACCEPTED", VALUEFUNC(_wrap_PosMaintStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_COMPLETED_WITH_WARNINGS", VALUEFUNC(_wrap_PosMaintStatus_COMPLETED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_6_MO_LIBOR", VALUEFUNC(_wrap_Benchmark_6_MO_LIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD_5", VALUEFUNC(_wrap_Benchmark_OLD_5_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD_30", VALUEFUNC(_wrap_Benchmark_OLD_30_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_3_MO_LIBOR", VALUEFUNC(_wrap_Benchmark_3_MO_LIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD_10", VALUEFUNC(_wrap_Benchmark_OLD_10_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_CURVE", VALUEFUNC(_wrap_Benchmark_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_30_YR", VALUEFUNC(_wrap_Benchmark_30_YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_10_YR", VALUEFUNC(_wrap_Benchmark_10_YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_5_YR", VALUEFUNC(_wrap_Benchmark_5_YR_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearFormat_YEARMONTHWEEK", VALUEFUNC(_wrap_MaturityMonthYearFormat_YEARMONTHWEEK_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearFormat_YEARMONTHDAY", VALUEFUNC(_wrap_MaturityMonthYearFormat_YEARMONTHDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearFormat_YEARMONTH_ONLY", VALUEFUNC(_wrap_MaturityMonthYearFormat_YEARMONTH_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "LegalConfirm_NO", VALUEFUNC(_wrap_LegalConfirm_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LegalConfirm_YES", VALUEFUNC(_wrap_LegalConfirm_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM", VALUEFUNC(_wrap_ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED", VALUEFUNC(_wrap_ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM", VALUEFUNC(_wrap_ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID", VALUEFUNC(_wrap_ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_get), 0);
  rb_define_singleton_method(mQuickfix, "ReportToExch_NO", VALUEFUNC(_wrap_ReportToExch_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ReportToExch_YES", VALUEFUNC(_wrap_ReportToExch_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_ALLOCATED_QUANTITY", VALUEFUNC(_wrap_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_ORDERID", VALUEFUNC(_wrap_AllocRejCode_UNKNOWN_ORDERID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_AVERAGEG_PRICE", VALUEFUNC(_wrap_AllocRejCode_INCORRECT_AVERAGEG_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_WAREHOUSE_REQUEST_REJECTED", VALUEFUNC(_wrap_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_OTHER_99", VALUEFUNC(_wrap_AllocRejCode_OTHER_99_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_LISTID", VALUEFUNC(_wrap_AllocRejCode_UNKNOWN_LISTID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_QUANTITY", VALUEFUNC(_wrap_AllocRejCode_INCORRECT_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_AVERAGE_PRICE", VALUEFUNC(_wrap_AllocRejCode_INCORRECT_AVERAGE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_ACCOUNT", VALUEFUNC(_wrap_AllocRejCode_UNKNOWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_OR_STALE_EXECID", VALUEFUNC(_wrap_AllocRejCode_UNKNOWN_OR_STALE_EXECID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_MISMATCHED_DATA_VALUE", VALUEFUNC(_wrap_AllocRejCode_MISMATCHED_DATA_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_OTHER", VALUEFUNC(_wrap_AllocRejCode_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_OTHER_7", VALUEFUNC(_wrap_AllocRejCode_OTHER_7_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_CLORDID", VALUEFUNC(_wrap_AllocRejCode_UNKNOWN_CLORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_MISMATCHED_DATA", VALUEFUNC(_wrap_AllocRejCode_MISMATCHED_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_CALCULATION_DIFFERENCE", VALUEFUNC(_wrap_AllocRejCode_CALCULATION_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_COMMISSION_DIFFERENCE", VALUEFUNC(_wrap_AllocRejCode_COMMISSION_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC", VALUEFUNC(_wrap_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrdIDReason_GTC_FROM_PREVIOUS_DAY", VALUEFUNC(_wrap_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrdIDReason_PARTIAL_FILL_REMAINING", VALUEFUNC(_wrap_RefOrdIDReason_PARTIAL_FILL_REMAINING_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrdIDReason_ORDER_CHANGED", VALUEFUNC(_wrap_RefOrdIDReason_ORDER_CHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_SECONDARYORDERID", VALUEFUNC(_wrap_RefOrderIDSource_SECONDARYORDERID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_ORDERID", VALUEFUNC(_wrap_RefOrderIDSource_ORDERID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_MDENTRYID", VALUEFUNC(_wrap_RefOrderIDSource_MDENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_ORIGINAL_ORDER_ID", VALUEFUNC(_wrap_RefOrderIDSource_ORIGINAL_ORDER_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_MENTRYID", VALUEFUNC(_wrap_RefOrderIDSource_MENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_QUOTEENTRYID", VALUEFUNC(_wrap_RefOrderIDSource_QUOTEENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_QUOTENTRYID", VALUEFUNC(_wrap_RefOrderIDSource_QUOTENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_ORDEID", VALUEFUNC(_wrap_RefOrderIDSource_ORDEID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_SECONDARYORDEID", VALUEFUNC(_wrap_RefOrderIDSource_SECONDARYORDEID_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_CROSS_AS_PRINCIPAL", VALUEFUNC(_wrap_LastCapacity_CROSS_AS_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_PRINCIPAL", VALUEFUNC(_wrap_LastCapacity_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_CROSS_AS_AGENT", VALUEFUNC(_wrap_LastCapacity_CROSS_AS_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_AGENT", VALUEFUNC(_wrap_LastCapacity_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_STRIKE_PRICE", VALUEFUNC(_wrap_InstrAttribType_INSTRUMENT_STRIKE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_IN_DEFAULT", VALUEFUNC(_wrap_InstrAttribType_IN_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_PRE_REFUNDED", VALUEFUNC(_wrap_InstrAttribType_PRE_REFUNDED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX", VALUEFUNC(_wrap_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ORIGINAL_ISSUE_DISCOUNT", VALUEFUNC(_wrap_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_UNRATED", VALUEFUNC(_wrap_InstrAttribType_UNRATED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_WHEN_AND_IF_ISSUED", VALUEFUNC(_wrap_InstrAttribType_WHEN_AND_IF_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED", VALUEFUNC(_wrap_InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE", VALUEFUNC(_wrap_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_STEPPED_COUPON", VALUEFUNC(_wrap_InstrAttribType_STEPPED_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_DENOMINATOR", VALUEFUNC(_wrap_InstrAttribType_INSTRUMENT_DENOMINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWED_TO_REDEMPTION_DATE", VALUEFUNC(_wrap_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TAXABLE", VALUEFUNC(_wrap_InstrAttribType_TAXABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INTEREST_BEARING", VALUEFUNC(_wrap_InstrAttribType_INTEREST_BEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE", VALUEFUNC(_wrap_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_PREREFUNDED", VALUEFUNC(_wrap_InstrAttribType_PREREFUNDED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLE_PUTTABLE", VALUEFUNC(_wrap_InstrAttribType_CALLABLE_PUTTABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_COUPON_PERIOD", VALUEFUNC(_wrap_InstrAttribType_COUPON_PERIOD_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_PRICE_PRECISION", VALUEFUNC(_wrap_InstrAttribType_INSTRUMENT_PRICE_PRECISION_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TRADEABLE_INDICATOR", VALUEFUNC(_wrap_InstrAttribType_TRADEABLE_INDICATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE", VALUEFUNC(_wrap_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_VARIABLE_RATE", VALUEFUNC(_wrap_InstrAttribType_VARIABLE_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_FLAT", VALUEFUNC(_wrap_InstrAttribType_FLAT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY", VALUEFUNC(_wrap_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_NUMERATOR", VALUEFUNC(_wrap_InstrAttribType_INSTRUMENT_NUMERATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE", VALUEFUNC(_wrap_InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INDEXED", VALUEFUNC(_wrap_InstrAttribType_INDEXED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWED_TO_MATURITY", VALUEFUNC(_wrap_InstrAttribType_ESCROWED_TO_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_LESS_FEE_FOR_PUT", VALUEFUNC(_wrap_InstrAttribType_LESS_FEE_FOR_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ZERO_COUPON", VALUEFUNC(_wrap_InstrAttribType_ZERO_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY", VALUEFUNC(_wrap_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_NO_PERIODIC_PAYMENTS", VALUEFUNC(_wrap_InstrAttribType_NO_PERIODIC_PAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_FINANCING", VALUEFUNC(_wrap_Product_FINANCING_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_COMMODITY", VALUEFUNC(_wrap_Product_COMMODITY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_EQUITY", VALUEFUNC(_wrap_Product_EQUITY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_CORPORATE", VALUEFUNC(_wrap_Product_CORPORATE_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_AGENCY", VALUEFUNC(_wrap_Product_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_OTHER", VALUEFUNC(_wrap_Product_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_MONEYMARKET", VALUEFUNC(_wrap_Product_MONEYMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_MORTGAGE", VALUEFUNC(_wrap_Product_MORTGAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_CURRENCY", VALUEFUNC(_wrap_Product_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_INDEX", VALUEFUNC(_wrap_Product_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_MUNICIPAL", VALUEFUNC(_wrap_Product_MUNICIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_LOAN", VALUEFUNC(_wrap_Product_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_GOVERNMENT", VALUEFUNC(_wrap_Product_GOVERNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_FAST_MARKET", VALUEFUNC(_wrap_SecurityTradingStatus_FAST_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_OPEN_NO_RESUME", VALUEFUNC(_wrap_SecurityTradingStatus_NO_OPEN_NO_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRADING_HALT", VALUEFUNC(_wrap_SecurityTradingStatus_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING", VALUEFUNC(_wrap_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_OPEN", VALUEFUNC(_wrap_SecurityTradingStatus_NO_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_CROSS", VALUEFUNC(_wrap_SecurityTradingStatus_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_RESUME", VALUEFUNC(_wrap_SecurityTradingStatus_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRADE_DISSEMINATION_TIME", VALUEFUNC(_wrap_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE", VALUEFUNC(_wrap_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_POST_CLOSE", VALUEFUNC(_wrap_SecurityTradingStatus_POST_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY", VALUEFUNC(_wrap_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_IMBALANCE_SELL", VALUEFUNC(_wrap_SecurityTradingStatus_MARKET_IMBALANCE_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_OPENING_DELAY", VALUEFUNC(_wrap_SecurityTradingStatus_OPENING_DELAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET", VALUEFUNC(_wrap_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_ITS_PRE_OPENING", VALUEFUNC(_wrap_SecurityTradingStatus_ITS_PRE_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PRE_CROSS", VALUEFUNC(_wrap_SecurityTradingStatus_PRE_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PRE_OPEN", VALUEFUNC(_wrap_SecurityTradingStatus_PRE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_IMBALANCE_BUY", VALUEFUNC(_wrap_SecurityTradingStatus_MARKET_IMBALANCE_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRADING_RANGE_INDICATION", VALUEFUNC(_wrap_SecurityTradingStatus_TRADING_RANGE_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_READY_TO_TRADE", VALUEFUNC(_wrap_SecurityTradingStatus_READY_TO_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NEW_PRICE_INDICATION", VALUEFUNC(_wrap_SecurityTradingStatus_NEW_PRICE_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_OPENING_ROTATION", VALUEFUNC(_wrap_SecurityTradingStatus_OPENING_ROTATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PRICE_INDICATION", VALUEFUNC(_wrap_SecurityTradingStatus_PRICE_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_UNKNOWN_OR_INVALID", VALUEFUNC(_wrap_SecurityTradingStatus_UNKNOWN_OR_INVALID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL", VALUEFUNC(_wrap_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_MARKET_IMBALANCE", VALUEFUNC(_wrap_SecurityTradingStatus_NO_MARKET_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER", VALUEFUNC(_wrap_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SPECIALIST_TRADES", VALUEFUNC(_wrap_Rule80A_SPECIALIST_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_F", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_F_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETING_DEALER_TRADES_O", VALUEFUNC(_wrap_Rule80A_COMPETING_DEALER_TRADES_O_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_H", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_H_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRINCIPAL", VALUEFUNC(_wrap_Rule80A_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETING_DEALER_TRADES_R", VALUEFUNC(_wrap_Rule80A_COMPETING_DEALER_TRADES_R_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER", VALUEFUNC(_wrap_Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER", VALUEFUNC(_wrap_Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETING_DEALER_TRADES_T", VALUEFUNC(_wrap_Rule80A_COMPETING_DEALER_TRADES_T_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER", VALUEFUNC(_wrap_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_B", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_B_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE", VALUEFUNC(_wrap_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_AGENCY_SINGLE_ORDER", VALUEFUNC(_wrap_Rule80A_AGENCY_SINGLE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER", VALUEFUNC(_wrap_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES", VALUEFUNC(_wrap_Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER", VALUEFUNC(_wrap_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_MERGER_REORGANIZATION", VALUEFUNC(_wrap_CorporateAction_MERGER_REORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SYMBOL_CONVERSION", VALUEFUNC(_wrap_CorporateAction_SYMBOL_CONVERSION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_NEW", VALUEFUNC(_wrap_CorporateAction_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SUCCESSION_EVENT", VALUEFUNC(_wrap_CorporateAction_SUCCESSION_EVENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_STOCK_DIVIDEND", VALUEFUNC(_wrap_CorporateAction_STOCK_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_REVERSE_STOCK_SPLIT", VALUEFUNC(_wrap_CorporateAction_REVERSE_STOCK_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_POSITION_CONSOLIDATION", VALUEFUNC(_wrap_CorporateAction_POSITION_CONSOLIDATION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SPINOFF", VALUEFUNC(_wrap_CorporateAction_SPINOFF_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_INTEREST", VALUEFUNC(_wrap_CorporateAction_EX_INTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_LIQUIDATION_REORGANIZATION", VALUEFUNC(_wrap_CorporateAction_LIQUIDATION_REORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_CASH_DIVIDEND", VALUEFUNC(_wrap_CorporateAction_CASH_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_STANDARD_INTEGER_STOCK_SPLIT", VALUEFUNC(_wrap_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_RIGHTS_OFFERING", VALUEFUNC(_wrap_CorporateAction_RIGHTS_OFFERING_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SHAREHOLDER_MEETING", VALUEFUNC(_wrap_CorporateAction_SHAREHOLDER_MEETING_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_WARRANT", VALUEFUNC(_wrap_CorporateAction_WARRANT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_RIGHTS", VALUEFUNC(_wrap_CorporateAction_EX_RIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_DISTRIBUTION", VALUEFUNC(_wrap_CorporateAction_EX_DISTRIBUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_DIVIDEND", VALUEFUNC(_wrap_CorporateAction_EX_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_TENDER_OFFER", VALUEFUNC(_wrap_CorporateAction_TENDER_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SPECIAL_ACTION", VALUEFUNC(_wrap_CorporateAction_SPECIAL_ACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_NON_INTEGER_STOCK_SPLIT", VALUEFUNC(_wrap_CorporateAction_NON_INTEGER_STOCK_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_CUSIP", VALUEFUNC(_wrap_CorporateAction_CUSIP_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_LEAP_ROLLOVER", VALUEFUNC(_wrap_CorporateAction_LEAP_ROLLOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_TERM", VALUEFUNC(_wrap_TerminationType_TERM_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_FLEXIBLE", VALUEFUNC(_wrap_TerminationType_FLEXIBLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_OPEN", VALUEFUNC(_wrap_TerminationType_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_OVERNIGHT", VALUEFUNC(_wrap_TerminationType_OVERNIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_NEW", VALUEFUNC(_wrap_PosMaintAction_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_REPLACE", VALUEFUNC(_wrap_PosMaintAction_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_REVERSE", VALUEFUNC(_wrap_PosMaintAction_REVERSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID", VALUEFUNC(_wrap_PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID", VALUEFUNC(_wrap_PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_CANCEL", VALUEFUNC(_wrap_PosMaintAction_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY", VALUEFUNC(_wrap_PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceTimeType_SPECIFIED_DATE_TIME", VALUEFUNC(_wrap_ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceTimeType_EXPIRATION", VALUEFUNC(_wrap_ComplexEventPriceTimeType_EXPIRATION_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceTimeType_IMMEDIATE", VALUEFUNC(_wrap_ComplexEventPriceTimeType_IMMEDIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingFXRateCalc_DIVIDE", VALUEFUNC(_wrap_UnderlyingFXRateCalc_DIVIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingFXRateCalc_MULTIPLY", VALUEFUNC(_wrap_UnderlyingFXRateCalc_MULTIPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "OddLot_NO", VALUEFUNC(_wrap_OddLot_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "OddLot_YES", VALUEFUNC(_wrap_OddLot_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE", VALUEFUNC(_wrap_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER", VALUEFUNC(_wrap_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT", VALUEFUNC(_wrap_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REJECTED_BY_INTERMEDIARY", VALUEFUNC(_wrap_AllocStatus_REJECTED_BY_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_BLOCK_LEVEL_REJECT", VALUEFUNC(_wrap_AllocStatus_BLOCK_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ACCOUNT_LEVEL_REJECT", VALUEFUNC(_wrap_AllocStatus_ACCOUNT_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_INCOMPLETE", VALUEFUNC(_wrap_AllocStatus_INCOMPLETE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ALLOCATION_PENDING", VALUEFUNC(_wrap_AllocStatus_ALLOCATION_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REVERSED", VALUEFUNC(_wrap_AllocStatus_REVERSED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_RECEIVED", VALUEFUNC(_wrap_AllocStatus_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_PARTIAL_ACCEPT", VALUEFUNC(_wrap_AllocStatus_PARTIAL_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REJECTED", VALUEFUNC(_wrap_AllocStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ACCEPTED", VALUEFUNC(_wrap_AllocStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "IncTaxInd_NET", VALUEFUNC(_wrap_IncTaxInd_NET_get), 0);
  rb_define_singleton_method(mQuickfix, "IncTaxInd_GROSS", VALUEFUNC(_wrap_IncTaxInd_GROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_COMPLETED", VALUEFUNC(_wrap_PosReqStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_REJECTED", VALUEFUNC(_wrap_PosReqStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_COMPLETED_WITH_WARNINGS", VALUEFUNC(_wrap_PosReqStatus_COMPLETED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriorityIndicator_PRIORITY_UNCHANGED", VALUEFUNC(_wrap_PriorityIndicator_PRIORITY_UNCHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE", VALUEFUNC(_wrap_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT", VALUEFUNC(_wrap_MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION", VALUEFUNC(_wrap_MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION", VALUEFUNC(_wrap_MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_NOT_CHECKED", VALUEFUNC(_wrap_MoneyLaunderingStatus_NOT_CHECKED_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_PASSED", VALUEFUNC(_wrap_MoneyLaunderingStatus_PASSED_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_1", VALUEFUNC(_wrap_MoneyLaunderingStatus_EXEMPT_1_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_2", VALUEFUNC(_wrap_MoneyLaunderingStatus_EXEMPT_2_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_3", VALUEFUNC(_wrap_MoneyLaunderingStatus_EXEMPT_3_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE", VALUEFUNC(_wrap_LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_ROUND_LOT", VALUEFUNC(_wrap_LotType_ROUND_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_ODD_LOT", VALUEFUNC(_wrap_LotType_ODD_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_BLOCK_LOT", VALUEFUNC(_wrap_LotType_BLOCK_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FLAT_CURVE", VALUEFUNC(_wrap_QuoteCondition_FLAT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_REST_OF_BOOK_VWAP", VALUEFUNC(_wrap_QuoteCondition_REST_OF_BOOK_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS", VALUEFUNC(_wrap_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_TRADING_RANGE", VALUEFUNC(_wrap_QuoteCondition_TRADING_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_HALT_ETH", VALUEFUNC(_wrap_QuoteCondition_HALT_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_BID_OFFER_SPECIALIST", VALUEFUNC(_wrap_QuoteCondition_BID_OFFER_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CROSSED", VALUEFUNC(_wrap_QuoteCondition_CROSSED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NO_OPEN", VALUEFUNC(_wrap_QuoteCondition_NO_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_HALT", VALUEFUNC(_wrap_QuoteCondition_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_PREOPENING_SAM", VALUEFUNC(_wrap_QuoteCondition_PREOPENING_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPEN_SAM", VALUEFUNC(_wrap_QuoteCondition_OPEN_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_RESERVED_SAM", VALUEFUNC(_wrap_QuoteCondition_RESERVED_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OUTRIGHT_PRICE", VALUEFUNC(_wrap_QuoteCondition_OUTRIGHT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_IMPLIED_PRICE", VALUEFUNC(_wrap_QuoteCondition_IMPLIED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DEPTH_ON_OFFER", VALUEFUNC(_wrap_QuoteCondition_DEPTH_ON_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED", VALUEFUNC(_wrap_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_REGULAR_ETH", VALUEFUNC(_wrap_QuoteCondition_REGULAR_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ROTATION_ETH", VALUEFUNC(_wrap_QuoteCondition_ROTATION_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_EXCHANGE_BEST", VALUEFUNC(_wrap_QuoteCondition_EXCHANGE_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DEPTH_ON_BID", VALUEFUNC(_wrap_QuoteCondition_DEPTH_ON_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CLOSING", VALUEFUNC(_wrap_QuoteCondition_CLOSING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_VIEW_OF_COMMON", VALUEFUNC(_wrap_QuoteCondition_VIEW_OF_COMMON_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FORBIDDEN_SAM", VALUEFUNC(_wrap_QuoteCondition_FORBIDDEN_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_LOCKED", VALUEFUNC(_wrap_QuoteCondition_LOCKED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ORDER_INFLUX", VALUEFUNC(_wrap_QuoteCondition_ORDER_INFLUX_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NEWS_PENDING", VALUEFUNC(_wrap_QuoteCondition_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_RESUME", VALUEFUNC(_wrap_QuoteCondition_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_TRADING_RESUME", VALUEFUNC(_wrap_QuoteCondition_TRADING_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OUT_OF_SEQUENCE", VALUEFUNC(_wrap_QuoteCondition_OUT_OF_SEQUENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_END_OF_DAY_SAM", VALUEFUNC(_wrap_QuoteCondition_END_OF_DAY_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FROZEN_SAM", VALUEFUNC(_wrap_QuoteCondition_FROZEN_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPENING_SAM", VALUEFUNC(_wrap_QuoteCondition_OPENING_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_MANUAL_SLOW_QUOTE", VALUEFUNC(_wrap_QuoteCondition_MANUAL_SLOW_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NEWS_DISSEMINATION", VALUEFUNC(_wrap_QuoteCondition_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DUE_TO_RELATED", VALUEFUNC(_wrap_QuoteCondition_DUE_TO_RELATED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_VOLUME_ALERT", VALUEFUNC(_wrap_QuoteCondition_VOLUME_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FAST_MARKET_ETH", VALUEFUNC(_wrap_QuoteCondition_FAST_MARKET_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_INACTIVE_ETH", VALUEFUNC(_wrap_QuoteCondition_INACTIVE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DUE_TO_NEWS_DISSEMINATION", VALUEFUNC(_wrap_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_SURVEILLANCE_SAM", VALUEFUNC(_wrap_QuoteCondition_SURVEILLANCE_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DEPTH", VALUEFUNC(_wrap_QuoteCondition_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPEN", VALUEFUNC(_wrap_QuoteCondition_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_AUTOMATIC_EXECUTION", VALUEFUNC(_wrap_QuoteCondition_AUTOMATIC_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DUE_TO_NEWS_PENDING", VALUEFUNC(_wrap_QuoteCondition_DUE_TO_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NO_ACTIVE_SAM", VALUEFUNC(_wrap_QuoteCondition_NO_ACTIVE_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OFFER_SPECIALIST", VALUEFUNC(_wrap_QuoteCondition_OFFER_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_SUSPENDED_SAM", VALUEFUNC(_wrap_QuoteCondition_SUSPENDED_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_RESTRICTED", VALUEFUNC(_wrap_QuoteCondition_RESTRICTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NON_FIRM", VALUEFUNC(_wrap_QuoteCondition_NON_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CLOSED_INACTIVE", VALUEFUNC(_wrap_QuoteCondition_CLOSED_INACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ADDITIONAL_INFO", VALUEFUNC(_wrap_QuoteCondition_ADDITIONAL_INFO_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_EQUIPMENT_CHANGEOVER", VALUEFUNC(_wrap_QuoteCondition_EQUIPMENT_CHANGEOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FAST_TRADING", VALUEFUNC(_wrap_QuoteCondition_FAST_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FULL_CURVE", VALUEFUNC(_wrap_QuoteCondition_FULL_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_MEDIAN_PRICE", VALUEFUNC(_wrap_QuoteCondition_MEDIAN_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPEN_ACTIVE", VALUEFUNC(_wrap_QuoteCondition_OPEN_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ORDER_IMBALANCE", VALUEFUNC(_wrap_QuoteCondition_ORDER_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_AUTOMATIC_EXECUTION_ETH", VALUEFUNC(_wrap_QuoteCondition_AUTOMATIC_EXECUTION_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ROTATION", VALUEFUNC(_wrap_QuoteCondition_ROTATION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_BID_SPECIALIST", VALUEFUNC(_wrap_QuoteCondition_BID_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CONSOLIDATED_BEST", VALUEFUNC(_wrap_QuoteCondition_CONSOLIDATED_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CLOSED", VALUEFUNC(_wrap_QuoteCondition_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_EUROCLEAR", VALUEFUNC(_wrap_SettlLocation_EUROCLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_CEDEL", VALUEFUNC(_wrap_SettlLocation_CEDEL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_PARTICIPANT_TRUST_COMPANY", VALUEFUNC(_wrap_SettlLocation_PARTICIPANT_TRUST_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_PHYSICAL", VALUEFUNC(_wrap_SettlLocation_PHYSICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_DEPOSITORY_TRUST_COMPANY", VALUEFUNC(_wrap_SettlLocation_DEPOSITORY_TRUST_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_LOCAL_MARKET_SETTLE_LOCATION", VALUEFUNC(_wrap_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_FEDERAL_BOOK_ENTRY", VALUEFUNC(_wrap_SettlLocation_FEDERAL_BOOK_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_NATIONAL_EXCLUDING_LOCAL", VALUEFUNC(_wrap_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_LOCAL", VALUEFUNC(_wrap_DiscretionScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_GLOBAL", VALUEFUNC(_wrap_DiscretionScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_NATIONAL", VALUEFUNC(_wrap_DiscretionScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PUBLIC_COMPANY", VALUEFUNC(_wrap_OwnerType_PUBLIC_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_INDIVIDUAL_TRUSTEE", VALUEFUNC(_wrap_OwnerType_INDIVIDUAL_TRUSTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT", VALUEFUNC(_wrap_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_INDIVIDUAL_INVESTOR", VALUEFUNC(_wrap_OwnerType_INDIVIDUAL_INVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_COMPANY_TRUSTEE", VALUEFUNC(_wrap_OwnerType_COMPANY_TRUSTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PRIVATE_COMPANY", VALUEFUNC(_wrap_OwnerType_PRIVATE_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NETWORKING_SUB_ACCOUNT", VALUEFUNC(_wrap_OwnerType_NETWORKING_SUB_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PENSION_PLAN", VALUEFUNC(_wrap_OwnerType_PENSION_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_TRUSTS", VALUEFUNC(_wrap_OwnerType_TRUSTS_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_FIDUCIARIES", VALUEFUNC(_wrap_OwnerType_FIDUCIARIES_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NON_PROFIT_ORGANIZATION", VALUEFUNC(_wrap_OwnerType_NON_PROFIT_ORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_CORPORATE_BODY", VALUEFUNC(_wrap_OwnerType_CORPORATE_BODY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NOMINEE", VALUEFUNC(_wrap_OwnerType_NOMINEE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_END_SESSION", VALUEFUNC(_wrap_ApplQueueResolution_END_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_QUEUE_FLUSHED", VALUEFUNC(_wrap_ApplQueueResolution_QUEUE_FLUSHED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_OVERLAY_LAST", VALUEFUNC(_wrap_ApplQueueResolution_OVERLAY_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_NO_ACTION_TAKEN", VALUEFUNC(_wrap_ApplQueueResolution_NO_ACTION_TAKEN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT", VALUEFUNC(_wrap_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES", VALUEFUNC(_wrap_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE", VALUEFUNC(_wrap_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES", VALUEFUNC(_wrap_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_NO_ACKNOWLEDGEMENT", VALUEFUNC(_wrap_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecAckStatus_RECEIVED_NOT_YET_PROCESSED", VALUEFUNC(_wrap_ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecAckStatus_DONT_KNOW", VALUEFUNC(_wrap_ExecAckStatus_DONT_KNOW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecAckStatus_ACCEPTED", VALUEFUNC(_wrap_ExecAckStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "NetGrossInd_NET", VALUEFUNC(_wrap_NetGrossInd_NET_get), 0);
  rb_define_singleton_method(mQuickfix, "NetGrossInd_GROSS", VALUEFUNC(_wrap_NetGrossInd_GROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlType_PARTIAL_CANCEL", VALUEFUNC(_wrap_CxlType_PARTIAL_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlType_FULL_REMAINING_QUANTITY", VALUEFUNC(_wrap_CxlType_FULL_REMAINING_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskTypeSource_NASD_OATS", VALUEFUNC(_wrap_DeskTypeSource_NASD_OATS_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK", VALUEFUNC(_wrap_DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MORE_AGGRESSIVE", VALUEFUNC(_wrap_DiscretionRoundDirection_MORE_AGGRESSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MORE_PASSIVE", VALUEFUNC(_wrap_DiscretionRoundDirection_MORE_PASSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK", VALUEFUNC(_wrap_DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "BidDescriptorType_COUNTRY", VALUEFUNC(_wrap_BidDescriptorType_COUNTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "BidDescriptorType_INDEX", VALUEFUNC(_wrap_BidDescriptorType_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "BidDescriptorType_SECTOR", VALUEFUNC(_wrap_BidDescriptorType_SECTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkStatusResponseType_INCREMENTAL_UPDATE", VALUEFUNC(_wrap_NetworkStatusResponseType_INCREMENTAL_UPDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkStatusResponseType_FULL", VALUEFUNC(_wrap_NetworkStatusResponseType_FULL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_INDICATIVE", VALUEFUNC(_wrap_QuoteType_INDICATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_RESTRICTED_TRADEABLE", VALUEFUNC(_wrap_QuoteType_RESTRICTED_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_TRADEABLE", VALUEFUNC(_wrap_QuoteType_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_COUNTER", VALUEFUNC(_wrap_QuoteType_COUNTER_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_MARKET_PRICE", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_MARKET_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_VWAP", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_MIDPOINT_PRICE", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_DISPLAYED_PRICE", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_PRIMARY_PRICE", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_PRIMARY_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_AVERAGE_PRICE_GUARANTEE", VALUEFUNC(_wrap_DiscretionInst_AVERAGE_PRICE_GUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_LAST_TRADE_PRICE", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE", VALUEFUNC(_wrap_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_BUY_SIDE_IS_PRIORITIZED", VALUEFUNC(_wrap_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_SELL_SIDE_IS_PRIORITIZED", VALUEFUNC(_wrap_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_NONE", VALUEFUNC(_wrap_CrossPrioritization_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_SELLSIDE_PRIORITIZED", VALUEFUNC(_wrap_CrossPrioritization_SELLSIDE_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_BUYSIDE_PRIORITIZED", VALUEFUNC(_wrap_CrossPrioritization_BUYSIDE_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIOthSvc_AUTEX", VALUEFUNC(_wrap_IOIOthSvc_AUTEX_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIOthSvc_BRIDGE", VALUEFUNC(_wrap_IOIOthSvc_BRIDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MDENTRYTYPE", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSUFFICIENT_CREDIT", VALUEFUNC(_wrap_MDReqRejReason_INSUFFICIENT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSUFFICIENT_BANDWIDTH", VALUEFUNC(_wrap_MDReqRejReason_INSUFFICIENT_BANDWIDTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_SCOPE", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_SCOPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_DUPLICATE_MDREQID", VALUEFUNC(_wrap_MDReqRejReason_DUPLICATE_MDREQID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MDUPDATETYPE", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNKNOWN_SYMBOL", VALUEFUNC(_wrap_MDReqRejReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MARKETDEPTH", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSUFFICIENT_PERMISSIONS", VALUEFUNC(_wrap_MDReqRejReason_INSUFFICIENT_PERMISSIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE", VALUEFUNC(_wrap_MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(_wrap_ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(_wrap_ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(_wrap_ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(_wrap_ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(_wrap_ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS", VALUEFUNC(_wrap_ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_CANCEL_RETRANSMISSION", VALUEFUNC(_wrap_ApplReqType_CANCEL_RETRANSMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "AggressorIndicator_NO", VALUEFUNC(_wrap_AggressorIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "AggressorIndicator_YES", VALUEFUNC(_wrap_AggressorIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_SECURITY", VALUEFUNC(_wrap_BusinessRejectReason_UNKNOWN_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_APPLICATION_NOT_AVAILABLE", VALUEFUNC(_wrap_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_INVALID_PRICE_INCREMENT", VALUEFUNC(_wrap_BusinessRejectReason_INVALID_PRICE_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME", VALUEFUNC(_wrap_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING", VALUEFUNC(_wrap_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_ID", VALUEFUNC(_wrap_BusinessRejectReason_UNKNOWN_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_OTHER", VALUEFUNC(_wrap_BusinessRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE", VALUEFUNC(_wrap_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_MESSAGE_TYPE", VALUEFUNC(_wrap_BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_NOT_AUTHORIZED", VALUEFUNC(_wrap_BusinessRejectReason_NOT_AUTHORIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKOWN_ID", VALUEFUNC(_wrap_BusinessRejectReason_UNKOWN_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_REGULAR_BOOKING", VALUEFUNC(_wrap_BookingType_REGULAR_BOOKING_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_CFD", VALUEFUNC(_wrap_BookingType_CFD_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_TOTAL_RETURN_SWAP", VALUEFUNC(_wrap_BookingType_TOTAL_RETURN_SWAP_get), 0);
  
  SwigClassSessionID.klass = rb_define_class_under(mQuickfix, "SessionID", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionID, (void *) &SwigClassSessionID);
  rb_define_alloc_func(SwigClassSessionID.klass, _wrap_SessionID_allocate);
  rb_define_method(SwigClassSessionID.klass, "initialize", VALUEFUNC(_wrap_new_SessionID), -1);
  rb_define_method(SwigClassSessionID.klass, "getBeginString", VALUEFUNC(_wrap_SessionID_getBeginString), -1);
  rb_define_method(SwigClassSessionID.klass, "getSenderCompID", VALUEFUNC(_wrap_SessionID_getSenderCompID), -1);
  rb_define_method(SwigClassSessionID.klass, "getTargetCompID", VALUEFUNC(_wrap_SessionID_getTargetCompID), -1);
  rb_define_method(SwigClassSessionID.klass, "getSessionQualifier", VALUEFUNC(_wrap_SessionID_getSessionQualifier), -1);
  rb_define_method(SwigClassSessionID.klass, "isFIXT", VALUEFUNC(_wrap_SessionID_isFIXT), -1);
  rb_define_method(SwigClassSessionID.klass, "toStringFrozen", VALUEFUNC(_wrap_SessionID_toStringFrozen), -1);
  rb_define_method(SwigClassSessionID.klass, "fromString", VALUEFUNC(_wrap_SessionID_fromString), -1);
  rb_define_method(SwigClassSessionID.klass, "toString", VALUEFUNC(_wrap_SessionID_toString), -1);
  rb_define_method(SwigClassSessionID.klass, "~", VALUEFUNC(_wrap_SessionID___invert__), -1);
  rb_define_method(SwigClassSessionID.klass, "to_s", VALUEFUNC(_wrap_SessionID___str__), -1);
  SwigClassSessionID.mark = 0;
  SwigClassSessionID.destroy = (void (*)(void *)) free_FIX_SessionID;
  SwigClassSessionID.trackObjects = 0;
  rb_define_module_function(mQuickfix, "<", VALUEFUNC(_wrap___lt__), -1);
  rb_define_module_function(mQuickfix, "==", VALUEFUNC(_wrap___eq__), -1);
  
  SwigClassDictionary.klass = rb_define_class_under(mQuickfix, "Dictionary", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Dictionary, (void *) &SwigClassDictionary);
  rb_define_alloc_func(SwigClassDictionary.klass, _wrap_Dictionary_allocate);
  rb_define_method(SwigClassDictionary.klass, "initialize", VALUEFUNC(_wrap_new_Dictionary), -1);
  rb_define_method(SwigClassDictionary.klass, "getName", VALUEFUNC(_wrap_Dictionary_getName), -1);
  rb_define_method(SwigClassDictionary.klass, "size", VALUEFUNC(_wrap_Dictionary_size), -1);
  rb_define_method(SwigClassDictionary.klass, "getString", VALUEFUNC(_wrap_Dictionary_getString), -1);
  rb_define_method(SwigClassDictionary.klass, "getLong", VALUEFUNC(_wrap_Dictionary_getLong), -1);
  rb_define_method(SwigClassDictionary.klass, "getDouble", VALUEFUNC(_wrap_Dictionary_getDouble), -1);
  rb_define_method(SwigClassDictionary.klass, "getBool", VALUEFUNC(_wrap_Dictionary_getBool), -1);
  rb_define_method(SwigClassDictionary.klass, "getDay", VALUEFUNC(_wrap_Dictionary_getDay), -1);
  rb_define_method(SwigClassDictionary.klass, "setString", VALUEFUNC(_wrap_Dictionary_setString), -1);
  rb_define_method(SwigClassDictionary.klass, "setLong", VALUEFUNC(_wrap_Dictionary_setLong), -1);
  rb_define_method(SwigClassDictionary.klass, "setDouble", VALUEFUNC(_wrap_Dictionary_setDouble), -1);
  rb_define_method(SwigClassDictionary.klass, "setBool", VALUEFUNC(_wrap_Dictionary_setBool), -1);
  rb_define_method(SwigClassDictionary.klass, "setDay", VALUEFUNC(_wrap_Dictionary_setDay), -1);
  rb_define_method(SwigClassDictionary.klass, "has", VALUEFUNC(_wrap_Dictionary_has), -1);
  rb_define_method(SwigClassDictionary.klass, "merge", VALUEFUNC(_wrap_Dictionary_merge), -1);
  rb_define_method(SwigClassDictionary.klass, "begin", VALUEFUNC(_wrap_Dictionary_begin), -1);
  rb_define_method(SwigClassDictionary.klass, "end", VALUEFUNC(_wrap_Dictionary_end), -1);
  SwigClassDictionary.mark = 0;
  SwigClassDictionary.destroy = (void (*)(void *)) free_FIX_Dictionary;
  SwigClassDictionary.trackObjects = 0;
  rb_define_singleton_method(mQuickfix, "BEGINSTRING", VALUEFUNC(_wrap_BEGINSTRING_get), 0);
  rb_define_singleton_method(mQuickfix, "SENDERCOMPID", VALUEFUNC(_wrap_SENDERCOMPID_get), 0);
  rb_define_singleton_method(mQuickfix, "TARGETCOMPID", VALUEFUNC(_wrap_TARGETCOMPID_get), 0);
  rb_define_singleton_method(mQuickfix, "SESSION_QUALIFIER", VALUEFUNC(_wrap_SESSION_QUALIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "DEFAULT_APPLVERID", VALUEFUNC(_wrap_DEFAULT_APPLVERID_get), 0);
  rb_define_singleton_method(mQuickfix, "CONNECTION_TYPE", VALUEFUNC(_wrap_CONNECTION_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "USE_DATA_DICTIONARY", VALUEFUNC(_wrap_USE_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "SEND_RESETSEQNUMFLAG", VALUEFUNC(_wrap_SEND_RESETSEQNUMFLAG_get), 0);
  rb_define_singleton_method(mQuickfix, "SEND_REDUNDANT_RESENDREQUESTS", VALUEFUNC(_wrap_SEND_REDUNDANT_RESENDREQUESTS_get), 0);
  rb_define_singleton_method(mQuickfix, "DATA_DICTIONARY", VALUEFUNC(_wrap_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "TRANSPORT_DATA_DICTIONARY", VALUEFUNC(_wrap_TRANSPORT_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "APP_DATA_DICTIONARY", VALUEFUNC(_wrap_APP_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "USE_LOCAL_TIME", VALUEFUNC(_wrap_USE_LOCAL_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "START_TIME", VALUEFUNC(_wrap_START_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "END_TIME", VALUEFUNC(_wrap_END_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "START_DAY", VALUEFUNC(_wrap_START_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "END_DAY", VALUEFUNC(_wrap_END_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGON_TIME", VALUEFUNC(_wrap_LOGON_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGOUT_TIME", VALUEFUNC(_wrap_LOGOUT_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGON_DAY", VALUEFUNC(_wrap_LOGON_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGOUT_DAY", VALUEFUNC(_wrap_LOGOUT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "CHECK_COMPID", VALUEFUNC(_wrap_CHECK_COMPID_get), 0);
  rb_define_singleton_method(mQuickfix, "CHECK_LATENCY", VALUEFUNC(_wrap_CHECK_LATENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "MAX_LATENCY", VALUEFUNC(_wrap_MAX_LATENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "HEARTBTINT", VALUEFUNC(_wrap_HEARTBTINT_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_ACCEPT_PORT", VALUEFUNC(_wrap_SOCKET_ACCEPT_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_REUSE_ADDRESS", VALUEFUNC(_wrap_SOCKET_REUSE_ADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_CONNECT_HOST", VALUEFUNC(_wrap_SOCKET_CONNECT_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_CONNECT_PORT", VALUEFUNC(_wrap_SOCKET_CONNECT_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_NODELAY", VALUEFUNC(_wrap_SOCKET_NODELAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_SEND_BUFFER_SIZE", VALUEFUNC(_wrap_SOCKET_SEND_BUFFER_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_RECEIVE_BUFFER_SIZE", VALUEFUNC(_wrap_SOCKET_RECEIVE_BUFFER_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "RECONNECT_INTERVAL", VALUEFUNC(_wrap_RECONNECT_INTERVAL_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_LENGTH_AND_CHECKSUM", VALUEFUNC(_wrap_VALIDATE_LENGTH_AND_CHECKSUM_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_FIELDS_OUT_OF_ORDER", VALUEFUNC(_wrap_VALIDATE_FIELDS_OUT_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_FIELDS_HAVE_VALUES", VALUEFUNC(_wrap_VALIDATE_FIELDS_HAVE_VALUES_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_USER_DEFINED_FIELDS", VALUEFUNC(_wrap_VALIDATE_USER_DEFINED_FIELDS_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGON_TIMEOUT", VALUEFUNC(_wrap_LOGON_TIMEOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGOUT_TIMEOUT", VALUEFUNC(_wrap_LOGOUT_TIMEOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "FILE_STORE_PATH", VALUEFUNC(_wrap_FILE_STORE_PATH_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_USECONNECTIONPOOL", VALUEFUNC(_wrap_MYSQL_STORE_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_DATABASE", VALUEFUNC(_wrap_MYSQL_STORE_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_USER", VALUEFUNC(_wrap_MYSQL_STORE_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_PASSWORD", VALUEFUNC(_wrap_MYSQL_STORE_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_HOST", VALUEFUNC(_wrap_MYSQL_STORE_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_PORT", VALUEFUNC(_wrap_MYSQL_STORE_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_USECONNECTIONPOOL", VALUEFUNC(_wrap_POSTGRESQL_STORE_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_DATABASE", VALUEFUNC(_wrap_POSTGRESQL_STORE_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_USER", VALUEFUNC(_wrap_POSTGRESQL_STORE_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_PASSWORD", VALUEFUNC(_wrap_POSTGRESQL_STORE_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_HOST", VALUEFUNC(_wrap_POSTGRESQL_STORE_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_PORT", VALUEFUNC(_wrap_POSTGRESQL_STORE_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_STORE_USER", VALUEFUNC(_wrap_ODBC_STORE_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_STORE_PASSWORD", VALUEFUNC(_wrap_ODBC_STORE_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_STORE_CONNECTION_STRING", VALUEFUNC(_wrap_ODBC_STORE_CONNECTION_STRING_get), 0);
  rb_define_singleton_method(mQuickfix, "FILE_LOG_PATH", VALUEFUNC(_wrap_FILE_LOG_PATH_get), 0);
  rb_define_singleton_method(mQuickfix, "FILE_LOG_BACKUP_PATH", VALUEFUNC(_wrap_FILE_LOG_BACKUP_PATH_get), 0);
  rb_define_singleton_method(mQuickfix, "SCREEN_LOG_SHOW_INCOMING", VALUEFUNC(_wrap_SCREEN_LOG_SHOW_INCOMING_get), 0);
  rb_define_singleton_method(mQuickfix, "SCREEN_LOG_SHOW_OUTGOING", VALUEFUNC(_wrap_SCREEN_LOG_SHOW_OUTGOING_get), 0);
  rb_define_singleton_method(mQuickfix, "SCREEN_LOG_SHOW_EVENTS", VALUEFUNC(_wrap_SCREEN_LOG_SHOW_EVENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_USECONNECTIONPOOL", VALUEFUNC(_wrap_MYSQL_LOG_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_DATABASE", VALUEFUNC(_wrap_MYSQL_LOG_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_USER", VALUEFUNC(_wrap_MYSQL_LOG_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_PASSWORD", VALUEFUNC(_wrap_MYSQL_LOG_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_HOST", VALUEFUNC(_wrap_MYSQL_LOG_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_PORT", VALUEFUNC(_wrap_MYSQL_LOG_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_INCOMING_TABLE", VALUEFUNC(_wrap_MYSQL_LOG_INCOMING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_OUTGOING_TABLE", VALUEFUNC(_wrap_MYSQL_LOG_OUTGOING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_EVENT_TABLE", VALUEFUNC(_wrap_MYSQL_LOG_EVENT_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_USECONNECTIONPOOL", VALUEFUNC(_wrap_POSTGRESQL_LOG_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_DATABASE", VALUEFUNC(_wrap_POSTGRESQL_LOG_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_USER", VALUEFUNC(_wrap_POSTGRESQL_LOG_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_PASSWORD", VALUEFUNC(_wrap_POSTGRESQL_LOG_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_HOST", VALUEFUNC(_wrap_POSTGRESQL_LOG_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_PORT", VALUEFUNC(_wrap_POSTGRESQL_LOG_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_INCOMING_TABLE", VALUEFUNC(_wrap_POSTGRESQL_LOG_INCOMING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_OUTGOING_TABLE", VALUEFUNC(_wrap_POSTGRESQL_LOG_OUTGOING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_EVENT_TABLE", VALUEFUNC(_wrap_POSTGRESQL_LOG_EVENT_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_USER", VALUEFUNC(_wrap_ODBC_LOG_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_PASSWORD", VALUEFUNC(_wrap_ODBC_LOG_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_CONNECTION_STRING", VALUEFUNC(_wrap_ODBC_LOG_CONNECTION_STRING_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_INCOMING_TABLE", VALUEFUNC(_wrap_ODBC_LOG_INCOMING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_OUTGOING_TABLE", VALUEFUNC(_wrap_ODBC_LOG_OUTGOING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_EVENT_TABLE", VALUEFUNC(_wrap_ODBC_LOG_EVENT_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "RESET_ON_LOGON", VALUEFUNC(_wrap_RESET_ON_LOGON_get), 0);
  rb_define_singleton_method(mQuickfix, "RESET_ON_LOGOUT", VALUEFUNC(_wrap_RESET_ON_LOGOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "RESET_ON_DISCONNECT", VALUEFUNC(_wrap_RESET_ON_DISCONNECT_get), 0);
  rb_define_singleton_method(mQuickfix, "REFRESH_ON_LOGON", VALUEFUNC(_wrap_REFRESH_ON_LOGON_get), 0);
  rb_define_singleton_method(mQuickfix, "MILLISECONDS_IN_TIMESTAMP", VALUEFUNC(_wrap_MILLISECONDS_IN_TIMESTAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "HTTP_ACCEPT_PORT", VALUEFUNC(_wrap_HTTP_ACCEPT_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "PERSIST_MESSAGES", VALUEFUNC(_wrap_PERSIST_MESSAGES_get), 0);
  
  SwigClassSessionSettings.klass = rb_define_class_under(mQuickfix, "SessionSettings", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionSettings, (void *) &SwigClassSessionSettings);
  rb_define_alloc_func(SwigClassSessionSettings.klass, _wrap_SessionSettings_allocate);
  rb_define_method(SwigClassSessionSettings.klass, "initialize", VALUEFUNC(_wrap_new_SessionSettings), -1);
  rb_define_method(SwigClassSessionSettings.klass, "has", VALUEFUNC(_wrap_SessionSettings_has), -1);
  rb_define_method(SwigClassSessionSettings.klass, "get", VALUEFUNC(_wrap_SessionSettings_get), -1);
  rb_define_method(SwigClassSessionSettings.klass, "set", VALUEFUNC(_wrap_SessionSettings_set), -1);
  rb_define_method(SwigClassSessionSettings.klass, "size", VALUEFUNC(_wrap_SessionSettings_size), -1);
  rb_define_method(SwigClassSessionSettings.klass, "getSessions", VALUEFUNC(_wrap_SessionSettings_getSessions), -1);
  SwigClassSessionSettings.mark = 0;
  SwigClassSessionSettings.destroy = (void (*)(void *)) free_FIX_SessionSettings;
  SwigClassSessionSettings.trackObjects = 0;
  rb_define_module_function(mQuickfix, ">>", VALUEFUNC(_wrap___rshift__), -1);
  rb_define_module_function(mQuickfix, "<<", VALUEFUNC(_wrap___lshift__), -1);
  
  SwigClassSession.klass = rb_define_class_under(mQuickfix, "Session", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Session, (void *) &SwigClassSession);
  rb_define_alloc_func(SwigClassSession.klass, _wrap_Session_allocate);
  rb_define_method(SwigClassSession.klass, "initialize", VALUEFUNC(_wrap_new_Session), -1);
  rb_define_method(SwigClassSession.klass, "logon", VALUEFUNC(_wrap_Session_logon), -1);
  rb_define_method(SwigClassSession.klass, "logout", VALUEFUNC(_wrap_Session_logout), -1);
  rb_define_method(SwigClassSession.klass, "isEnabled", VALUEFUNC(_wrap_Session_isEnabled), -1);
  rb_define_method(SwigClassSession.klass, "sentLogon", VALUEFUNC(_wrap_Session_sentLogon), -1);
  rb_define_method(SwigClassSession.klass, "sentLogout", VALUEFUNC(_wrap_Session_sentLogout), -1);
  rb_define_method(SwigClassSession.klass, "receivedLogon", VALUEFUNC(_wrap_Session_receivedLogon), -1);
  rb_define_method(SwigClassSession.klass, "isLoggedOn", VALUEFUNC(_wrap_Session_isLoggedOn), -1);
  rb_define_method(SwigClassSession.klass, "reset", VALUEFUNC(_wrap_Session_reset), -1);
  rb_define_method(SwigClassSession.klass, "refresh", VALUEFUNC(_wrap_Session_refresh), -1);
  rb_define_method(SwigClassSession.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_Session_setNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassSession.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_Session_setNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassSession.klass, "getSessionID", VALUEFUNC(_wrap_Session_getSessionID), -1);
  rb_define_method(SwigClassSession.klass, "setDataDictionaryProvider", VALUEFUNC(_wrap_Session_setDataDictionaryProvider), -1);
  rb_define_method(SwigClassSession.klass, "getDataDictionaryProvider", VALUEFUNC(_wrap_Session_getDataDictionaryProvider), -1);
  rb_define_singleton_method(SwigClassSession.klass, "sendToTarget", VALUEFUNC(_wrap_Session_sendToTarget), -1);
  rb_define_singleton_method(SwigClassSession.klass, "getSessions", VALUEFUNC(_wrap_Session_getSessions), -1);
  rb_define_singleton_method(SwigClassSession.klass, "doesSessionExist", VALUEFUNC(_wrap_Session_doesSessionExist), -1);
  rb_define_singleton_method(SwigClassSession.klass, "lookupSession", VALUEFUNC(_wrap_Session_lookupSession), -1);
  rb_define_singleton_method(SwigClassSession.klass, "isSessionRegistered", VALUEFUNC(_wrap_Session_isSessionRegistered), -1);
  rb_define_singleton_method(SwigClassSession.klass, "registerSession", VALUEFUNC(_wrap_Session_registerSession), -1);
  rb_define_singleton_method(SwigClassSession.klass, "unregisterSession", VALUEFUNC(_wrap_Session_unregisterSession), -1);
  rb_define_singleton_method(SwigClassSession.klass, "numSessions", VALUEFUNC(_wrap_Session_numSessions), -1);
  rb_define_method(SwigClassSession.klass, "isSessionTime", VALUEFUNC(_wrap_Session_isSessionTime), -1);
  rb_define_method(SwigClassSession.klass, "isLogonTime", VALUEFUNC(_wrap_Session_isLogonTime), -1);
  rb_define_method(SwigClassSession.klass, "isInitiator", VALUEFUNC(_wrap_Session_isInitiator), -1);
  rb_define_method(SwigClassSession.klass, "isAcceptor", VALUEFUNC(_wrap_Session_isAcceptor), -1);
  rb_define_method(SwigClassSession.klass, "getLogonTime", VALUEFUNC(_wrap_Session_getLogonTime), -1);
  rb_define_method(SwigClassSession.klass, "setLogonTime", VALUEFUNC(_wrap_Session_setLogonTime), -1);
  rb_define_method(SwigClassSession.klass, "getSenderDefaultApplVerID", VALUEFUNC(_wrap_Session_getSenderDefaultApplVerID), -1);
  rb_define_method(SwigClassSession.klass, "setSenderDefaultApplVerID", VALUEFUNC(_wrap_Session_setSenderDefaultApplVerID), -1);
  rb_define_method(SwigClassSession.klass, "getTargetDefaultApplVerID", VALUEFUNC(_wrap_Session_getTargetDefaultApplVerID), -1);
  rb_define_method(SwigClassSession.klass, "setTargetDefaultApplVerID", VALUEFUNC(_wrap_Session_setTargetDefaultApplVerID), -1);
  rb_define_method(SwigClassSession.klass, "getSendRedundantResendRequests", VALUEFUNC(_wrap_Session_getSendRedundantResendRequests), -1);
  rb_define_method(SwigClassSession.klass, "setSendRedundantResendRequests", VALUEFUNC(_wrap_Session_setSendRedundantResendRequests), -1);
  rb_define_method(SwigClassSession.klass, "getCheckCompId", VALUEFUNC(_wrap_Session_getCheckCompId), -1);
  rb_define_method(SwigClassSession.klass, "setCheckCompId", VALUEFUNC(_wrap_Session_setCheckCompId), -1);
  rb_define_method(SwigClassSession.klass, "getCheckLatency", VALUEFUNC(_wrap_Session_getCheckLatency), -1);
  rb_define_method(SwigClassSession.klass, "setCheckLatency", VALUEFUNC(_wrap_Session_setCheckLatency), -1);
  rb_define_method(SwigClassSession.klass, "getMaxLatency", VALUEFUNC(_wrap_Session_getMaxLatency), -1);
  rb_define_method(SwigClassSession.klass, "setMaxLatency", VALUEFUNC(_wrap_Session_setMaxLatency), -1);
  rb_define_method(SwigClassSession.klass, "getLogonTimeout", VALUEFUNC(_wrap_Session_getLogonTimeout), -1);
  rb_define_method(SwigClassSession.klass, "setLogonTimeout", VALUEFUNC(_wrap_Session_setLogonTimeout), -1);
  rb_define_method(SwigClassSession.klass, "getLogoutTimeout", VALUEFUNC(_wrap_Session_getLogoutTimeout), -1);
  rb_define_method(SwigClassSession.klass, "setLogoutTimeout", VALUEFUNC(_wrap_Session_setLogoutTimeout), -1);
  rb_define_method(SwigClassSession.klass, "getResetOnLogon", VALUEFUNC(_wrap_Session_getResetOnLogon), -1);
  rb_define_method(SwigClassSession.klass, "setResetOnLogon", VALUEFUNC(_wrap_Session_setResetOnLogon), -1);
  rb_define_method(SwigClassSession.klass, "getResetOnLogout", VALUEFUNC(_wrap_Session_getResetOnLogout), -1);
  rb_define_method(SwigClassSession.klass, "setResetOnLogout", VALUEFUNC(_wrap_Session_setResetOnLogout), -1);
  rb_define_method(SwigClassSession.klass, "getResetOnDisconnect", VALUEFUNC(_wrap_Session_getResetOnDisconnect), -1);
  rb_define_method(SwigClassSession.klass, "setResetOnDisconnect", VALUEFUNC(_wrap_Session_setResetOnDisconnect), -1);
  rb_define_method(SwigClassSession.klass, "getRefreshOnLogon", VALUEFUNC(_wrap_Session_getRefreshOnLogon), -1);
  rb_define_method(SwigClassSession.klass, "setRefreshOnLogon", VALUEFUNC(_wrap_Session_setRefreshOnLogon), -1);
  rb_define_method(SwigClassSession.klass, "getMillisecondsInTimeStamp", VALUEFUNC(_wrap_Session_getMillisecondsInTimeStamp), -1);
  rb_define_method(SwigClassSession.klass, "setMillisecondsInTimeStamp", VALUEFUNC(_wrap_Session_setMillisecondsInTimeStamp), -1);
  rb_define_method(SwigClassSession.klass, "getPersistMessages", VALUEFUNC(_wrap_Session_getPersistMessages), -1);
  rb_define_method(SwigClassSession.klass, "setPersistMessages", VALUEFUNC(_wrap_Session_setPersistMessages), -1);
  rb_define_method(SwigClassSession.klass, "getValidateLengthAndChecksum", VALUEFUNC(_wrap_Session_getValidateLengthAndChecksum), -1);
  rb_define_method(SwigClassSession.klass, "setValidateLengthAndChecksum", VALUEFUNC(_wrap_Session_setValidateLengthAndChecksum), -1);
  rb_define_method(SwigClassSession.klass, "setResponder", VALUEFUNC(_wrap_Session_setResponder), -1);
  rb_define_method(SwigClassSession.klass, "send", VALUEFUNC(_wrap_Session_send), -1);
  rb_define_method(SwigClassSession.klass, "next", VALUEFUNC(_wrap_Session_next), -1);
  rb_define_method(SwigClassSession.klass, "disconnect", VALUEFUNC(_wrap_Session_disconnect), -1);
  rb_define_method(SwigClassSession.klass, "getExpectedSenderNum", VALUEFUNC(_wrap_Session_getExpectedSenderNum), -1);
  rb_define_method(SwigClassSession.klass, "getExpectedTargetNum", VALUEFUNC(_wrap_Session_getExpectedTargetNum), -1);
  rb_define_method(SwigClassSession.klass, "getLog", VALUEFUNC(_wrap_Session_getLog), -1);
  rb_define_method(SwigClassSession.klass, "getStore", VALUEFUNC(_wrap_Session_getStore), -1);
  SwigClassSession.mark = 0;
  SwigClassSession.destroy = (void (*)(void *)) free_FIX_Session;
  SwigClassSession.trackObjects = 0;
  
  SwigClassLogFactory.klass = rb_define_class_under(mQuickfix, "LogFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LogFactory, (void *) &SwigClassLogFactory);
  rb_undef_alloc_func(SwigClassLogFactory.klass);
  rb_define_method(SwigClassLogFactory.klass, "create", VALUEFUNC(_wrap_LogFactory_create), -1);
  rb_define_method(SwigClassLogFactory.klass, "destroy", VALUEFUNC(_wrap_LogFactory_destroy), -1);
  SwigClassLogFactory.mark = 0;
  SwigClassLogFactory.destroy = (void (*)(void *)) free_FIX_LogFactory;
  SwigClassLogFactory.trackObjects = 0;
  
  SwigClassScreenLogFactory.klass = rb_define_class_under(mQuickfix, "ScreenLogFactory", ((swig_class *) SWIGTYPE_p_FIX__LogFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ScreenLogFactory, (void *) &SwigClassScreenLogFactory);
  rb_define_alloc_func(SwigClassScreenLogFactory.klass, _wrap_ScreenLogFactory_allocate);
  rb_define_method(SwigClassScreenLogFactory.klass, "initialize", VALUEFUNC(_wrap_new_ScreenLogFactory), -1);
  rb_define_method(SwigClassScreenLogFactory.klass, "create", VALUEFUNC(_wrap_ScreenLogFactory_create), -1);
  rb_define_method(SwigClassScreenLogFactory.klass, "destroy", VALUEFUNC(_wrap_ScreenLogFactory_destroy), -1);
  SwigClassScreenLogFactory.mark = 0;
  SwigClassScreenLogFactory.destroy = (void (*)(void *)) free_FIX_ScreenLogFactory;
  SwigClassScreenLogFactory.trackObjects = 0;
  
  SwigClassLog.klass = rb_define_class_under(mQuickfix, "Log", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Log, (void *) &SwigClassLog);
  rb_undef_alloc_func(SwigClassLog.klass);
  rb_define_method(SwigClassLog.klass, "clear", VALUEFUNC(_wrap_Log_clear), -1);
  rb_define_method(SwigClassLog.klass, "backup", VALUEFUNC(_wrap_Log_backup), -1);
  rb_define_method(SwigClassLog.klass, "onIncoming", VALUEFUNC(_wrap_Log_onIncoming), -1);
  rb_define_method(SwigClassLog.klass, "onOutgoing", VALUEFUNC(_wrap_Log_onOutgoing), -1);
  rb_define_method(SwigClassLog.klass, "onEvent", VALUEFUNC(_wrap_Log_onEvent), -1);
  SwigClassLog.mark = 0;
  SwigClassLog.destroy = (void (*)(void *)) free_FIX_Log;
  SwigClassLog.trackObjects = 0;
  
  SwigClassNullLog.klass = rb_define_class_under(mQuickfix, "NullLog", ((swig_class *) SWIGTYPE_p_FIX__Log->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NullLog, (void *) &SwigClassNullLog);
  rb_define_alloc_func(SwigClassNullLog.klass, _wrap_NullLog_allocate);
  rb_define_method(SwigClassNullLog.klass, "initialize", VALUEFUNC(_wrap_new_NullLog), -1);
  rb_define_method(SwigClassNullLog.klass, "clear", VALUEFUNC(_wrap_NullLog_clear), -1);
  rb_define_method(SwigClassNullLog.klass, "backup", VALUEFUNC(_wrap_NullLog_backup), -1);
  rb_define_method(SwigClassNullLog.klass, "onIncoming", VALUEFUNC(_wrap_NullLog_onIncoming), -1);
  rb_define_method(SwigClassNullLog.klass, "onOutgoing", VALUEFUNC(_wrap_NullLog_onOutgoing), -1);
  rb_define_method(SwigClassNullLog.klass, "onEvent", VALUEFUNC(_wrap_NullLog_onEvent), -1);
  SwigClassNullLog.mark = 0;
  SwigClassNullLog.destroy = (void (*)(void *)) free_FIX_NullLog;
  SwigClassNullLog.trackObjects = 0;
  
  SwigClassScreenLog.klass = rb_define_class_under(mQuickfix, "ScreenLog", ((swig_class *) SWIGTYPE_p_FIX__Log->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ScreenLog, (void *) &SwigClassScreenLog);
  rb_define_alloc_func(SwigClassScreenLog.klass, _wrap_ScreenLog_allocate);
  rb_define_method(SwigClassScreenLog.klass, "initialize", VALUEFUNC(_wrap_new_ScreenLog), -1);
  rb_define_method(SwigClassScreenLog.klass, "clear", VALUEFUNC(_wrap_ScreenLog_clear), -1);
  rb_define_method(SwigClassScreenLog.klass, "backup", VALUEFUNC(_wrap_ScreenLog_backup), -1);
  rb_define_method(SwigClassScreenLog.klass, "onIncoming", VALUEFUNC(_wrap_ScreenLog_onIncoming), -1);
  rb_define_method(SwigClassScreenLog.klass, "onOutgoing", VALUEFUNC(_wrap_ScreenLog_onOutgoing), -1);
  rb_define_method(SwigClassScreenLog.klass, "onEvent", VALUEFUNC(_wrap_ScreenLog_onEvent), -1);
  rb_define_method(SwigClassScreenLog.klass, "getMillisecondsInTimeStamp", VALUEFUNC(_wrap_ScreenLog_getMillisecondsInTimeStamp), -1);
  rb_define_method(SwigClassScreenLog.klass, "setMillisecondsInTimeStamp", VALUEFUNC(_wrap_ScreenLog_setMillisecondsInTimeStamp), -1);
  SwigClassScreenLog.mark = 0;
  SwigClassScreenLog.destroy = (void (*)(void *)) free_FIX_ScreenLog;
  SwigClassScreenLog.trackObjects = 0;
  
  SwigClassFileLogFactory.klass = rb_define_class_under(mQuickfix, "FileLogFactory", ((swig_class *) SWIGTYPE_p_FIX__LogFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileLogFactory, (void *) &SwigClassFileLogFactory);
  rb_define_alloc_func(SwigClassFileLogFactory.klass, _wrap_FileLogFactory_allocate);
  rb_define_method(SwigClassFileLogFactory.klass, "initialize", VALUEFUNC(_wrap_new_FileLogFactory), -1);
  rb_define_method(SwigClassFileLogFactory.klass, "create", VALUEFUNC(_wrap_FileLogFactory_create), -1);
  rb_define_method(SwigClassFileLogFactory.klass, "destroy", VALUEFUNC(_wrap_FileLogFactory_destroy), -1);
  SwigClassFileLogFactory.mark = 0;
  SwigClassFileLogFactory.destroy = (void (*)(void *)) free_FIX_FileLogFactory;
  SwigClassFileLogFactory.trackObjects = 0;
  
  SwigClassFileLog.klass = rb_define_class_under(mQuickfix, "FileLog", ((swig_class *) SWIGTYPE_p_FIX__Log->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileLog, (void *) &SwigClassFileLog);
  rb_define_alloc_func(SwigClassFileLog.klass, _wrap_FileLog_allocate);
  rb_define_method(SwigClassFileLog.klass, "initialize", VALUEFUNC(_wrap_new_FileLog), -1);
  rb_define_method(SwigClassFileLog.klass, "clear", VALUEFUNC(_wrap_FileLog_clear), -1);
  rb_define_method(SwigClassFileLog.klass, "backup", VALUEFUNC(_wrap_FileLog_backup), -1);
  rb_define_method(SwigClassFileLog.klass, "onIncoming", VALUEFUNC(_wrap_FileLog_onIncoming), -1);
  rb_define_method(SwigClassFileLog.klass, "onOutgoing", VALUEFUNC(_wrap_FileLog_onOutgoing), -1);
  rb_define_method(SwigClassFileLog.klass, "onEvent", VALUEFUNC(_wrap_FileLog_onEvent), -1);
  rb_define_method(SwigClassFileLog.klass, "getMillisecondsInTimeStamp", VALUEFUNC(_wrap_FileLog_getMillisecondsInTimeStamp), -1);
  rb_define_method(SwigClassFileLog.klass, "setMillisecondsInTimeStamp", VALUEFUNC(_wrap_FileLog_setMillisecondsInTimeStamp), -1);
  SwigClassFileLog.mark = 0;
  SwigClassFileLog.destroy = (void (*)(void *)) free_FIX_FileLog;
  SwigClassFileLog.trackObjects = 0;
  
  SwigClassMessageStoreFactory.klass = rb_define_class_under(mQuickfix, "MessageStoreFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStoreFactory, (void *) &SwigClassMessageStoreFactory);
  rb_undef_alloc_func(SwigClassMessageStoreFactory.klass);
  rb_define_method(SwigClassMessageStoreFactory.klass, "create", VALUEFUNC(_wrap_MessageStoreFactory_create), -1);
  rb_define_method(SwigClassMessageStoreFactory.klass, "destroy", VALUEFUNC(_wrap_MessageStoreFactory_destroy), -1);
  SwigClassMessageStoreFactory.mark = 0;
  SwigClassMessageStoreFactory.destroy = (void (*)(void *)) free_FIX_MessageStoreFactory;
  SwigClassMessageStoreFactory.trackObjects = 0;
  
  SwigClassMemoryStoreFactory.klass = rb_define_class_under(mQuickfix, "MemoryStoreFactory", ((swig_class *) SWIGTYPE_p_FIX__MessageStoreFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MemoryStoreFactory, (void *) &SwigClassMemoryStoreFactory);
  rb_define_alloc_func(SwigClassMemoryStoreFactory.klass, _wrap_MemoryStoreFactory_allocate);
  rb_define_method(SwigClassMemoryStoreFactory.klass, "initialize", VALUEFUNC(_wrap_new_MemoryStoreFactory), -1);
  rb_define_method(SwigClassMemoryStoreFactory.klass, "create", VALUEFUNC(_wrap_MemoryStoreFactory_create), -1);
  rb_define_method(SwigClassMemoryStoreFactory.klass, "destroy", VALUEFUNC(_wrap_MemoryStoreFactory_destroy), -1);
  SwigClassMemoryStoreFactory.mark = 0;
  SwigClassMemoryStoreFactory.destroy = (void (*)(void *)) free_FIX_MemoryStoreFactory;
  SwigClassMemoryStoreFactory.trackObjects = 0;
  
  SwigClassMessageStore.klass = rb_define_class_under(mQuickfix, "MessageStore", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStore, (void *) &SwigClassMessageStore);
  rb_undef_alloc_func(SwigClassMessageStore.klass);
  rb_define_method(SwigClassMessageStore.klass, "set", VALUEFUNC(_wrap_MessageStore_set), -1);
  rb_define_method(SwigClassMessageStore.klass, "get", VALUEFUNC(_wrap_MessageStore_get), -1);
  rb_define_method(SwigClassMessageStore.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStore_getNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStore.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStore_getNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStore.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStore_setNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStore.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStore_setNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStore.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStore_incrNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStore.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStore_incrNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStore.klass, "getCreationTime", VALUEFUNC(_wrap_MessageStore_getCreationTime), -1);
  rb_define_method(SwigClassMessageStore.klass, "reset", VALUEFUNC(_wrap_MessageStore_reset), -1);
  rb_define_method(SwigClassMessageStore.klass, "refresh", VALUEFUNC(_wrap_MessageStore_refresh), -1);
  SwigClassMessageStore.mark = 0;
  SwigClassMessageStore.destroy = (void (*)(void *)) free_FIX_MessageStore;
  SwigClassMessageStore.trackObjects = 0;
  
  SwigClassMemoryStore.klass = rb_define_class_under(mQuickfix, "MemoryStore", ((swig_class *) SWIGTYPE_p_FIX__MessageStore->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MemoryStore, (void *) &SwigClassMemoryStore);
  rb_define_alloc_func(SwigClassMemoryStore.klass, _wrap_MemoryStore_allocate);
  rb_define_method(SwigClassMemoryStore.klass, "initialize", VALUEFUNC(_wrap_new_MemoryStore), -1);
  rb_define_method(SwigClassMemoryStore.klass, "set", VALUEFUNC(_wrap_MemoryStore_set), -1);
  rb_define_method(SwigClassMemoryStore.klass, "get", VALUEFUNC(_wrap_MemoryStore_get), -1);
  rb_define_method(SwigClassMemoryStore.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_getNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMemoryStore.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_getNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMemoryStore.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_setNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMemoryStore.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_setNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMemoryStore.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_incrNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMemoryStore.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_incrNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMemoryStore.klass, "setCreationTime", VALUEFUNC(_wrap_MemoryStore_setCreationTime), -1);
  rb_define_method(SwigClassMemoryStore.klass, "getCreationTime", VALUEFUNC(_wrap_MemoryStore_getCreationTime), -1);
  rb_define_method(SwigClassMemoryStore.klass, "reset", VALUEFUNC(_wrap_MemoryStore_reset), -1);
  rb_define_method(SwigClassMemoryStore.klass, "refresh", VALUEFUNC(_wrap_MemoryStore_refresh), -1);
  SwigClassMemoryStore.mark = 0;
  SwigClassMemoryStore.destroy = (void (*)(void *)) free_FIX_MemoryStore;
  SwigClassMemoryStore.trackObjects = 0;
  
  SwigClassMessageStoreFactoryExceptionWrapper.klass = rb_define_class_under(mQuickfix, "MessageStoreFactoryExceptionWrapper", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, (void *) &SwigClassMessageStoreFactoryExceptionWrapper);
  rb_define_alloc_func(SwigClassMessageStoreFactoryExceptionWrapper.klass, _wrap_MessageStoreFactoryExceptionWrapper_allocate);
  rb_define_method(SwigClassMessageStoreFactoryExceptionWrapper.klass, "initialize", VALUEFUNC(_wrap_new_MessageStoreFactoryExceptionWrapper), -1);
  rb_define_method(SwigClassMessageStoreFactoryExceptionWrapper.klass, "create", VALUEFUNC(_wrap_MessageStoreFactoryExceptionWrapper_create), -1);
  rb_define_method(SwigClassMessageStoreFactoryExceptionWrapper.klass, "destroy", VALUEFUNC(_wrap_MessageStoreFactoryExceptionWrapper_destroy), -1);
  SwigClassMessageStoreFactoryExceptionWrapper.mark = 0;
  SwigClassMessageStoreFactoryExceptionWrapper.destroy = (void (*)(void *)) free_FIX_MessageStoreFactoryExceptionWrapper;
  SwigClassMessageStoreFactoryExceptionWrapper.trackObjects = 0;
  
  SwigClassMessageStoreExceptionWrapper.klass = rb_define_class_under(mQuickfix, "MessageStoreExceptionWrapper", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, (void *) &SwigClassMessageStoreExceptionWrapper);
  rb_define_alloc_func(SwigClassMessageStoreExceptionWrapper.klass, _wrap_MessageStoreExceptionWrapper_allocate);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "initialize", VALUEFUNC(_wrap_new_MessageStoreExceptionWrapper), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "set", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_set), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "get", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_get), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "getCreationTime", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_getCreationTime), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "reset", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_reset), -1);
  rb_define_method(SwigClassMessageStoreExceptionWrapper.klass, "refresh", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_refresh), -1);
  SwigClassMessageStoreExceptionWrapper.mark = 0;
  SwigClassMessageStoreExceptionWrapper.destroy = (void (*)(void *)) free_FIX_MessageStoreExceptionWrapper;
  SwigClassMessageStoreExceptionWrapper.trackObjects = 0;
  
  SwigClassFileStoreFactory.klass = rb_define_class_under(mQuickfix, "FileStoreFactory", ((swig_class *) SWIGTYPE_p_FIX__MessageStoreFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileStoreFactory, (void *) &SwigClassFileStoreFactory);
  rb_define_alloc_func(SwigClassFileStoreFactory.klass, _wrap_FileStoreFactory_allocate);
  rb_define_method(SwigClassFileStoreFactory.klass, "initialize", VALUEFUNC(_wrap_new_FileStoreFactory), -1);
  rb_define_method(SwigClassFileStoreFactory.klass, "create", VALUEFUNC(_wrap_FileStoreFactory_create), -1);
  rb_define_method(SwigClassFileStoreFactory.klass, "destroy", VALUEFUNC(_wrap_FileStoreFactory_destroy), -1);
  SwigClassFileStoreFactory.mark = 0;
  SwigClassFileStoreFactory.destroy = (void (*)(void *)) free_FIX_FileStoreFactory;
  SwigClassFileStoreFactory.trackObjects = 0;
  
  SwigClassFileStore.klass = rb_define_class_under(mQuickfix, "FileStore", ((swig_class *) SWIGTYPE_p_FIX__MessageStore->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileStore, (void *) &SwigClassFileStore);
  rb_define_alloc_func(SwigClassFileStore.klass, _wrap_FileStore_allocate);
  rb_define_method(SwigClassFileStore.klass, "initialize", VALUEFUNC(_wrap_new_FileStore), -1);
  rb_define_method(SwigClassFileStore.klass, "set", VALUEFUNC(_wrap_FileStore_set), -1);
  rb_define_method(SwigClassFileStore.klass, "get", VALUEFUNC(_wrap_FileStore_get), -1);
  rb_define_method(SwigClassFileStore.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_FileStore_getNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassFileStore.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_FileStore_getNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassFileStore.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_FileStore_setNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassFileStore.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_FileStore_setNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassFileStore.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_FileStore_incrNextSenderMsgSeqNum), -1);
  rb_define_method(SwigClassFileStore.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_FileStore_incrNextTargetMsgSeqNum), -1);
  rb_define_method(SwigClassFileStore.klass, "getCreationTime", VALUEFUNC(_wrap_FileStore_getCreationTime), -1);
  rb_define_method(SwigClassFileStore.klass, "reset", VALUEFUNC(_wrap_FileStore_reset), -1);
  rb_define_method(SwigClassFileStore.klass, "refresh", VALUEFUNC(_wrap_FileStore_refresh), -1);
  SwigClassFileStore.mark = 0;
  SwigClassFileStore.destroy = (void (*)(void *)) free_FIX_FileStore;
  SwigClassFileStore.trackObjects = 0;
  rb_define_module_function(mQuickfix, "disown_Application", VALUEFUNC(_wrap_disown_Application), -1);
  
  SwigClassApplication.klass = rb_define_class_under(mQuickfix, "Application", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Application, (void *) &SwigClassApplication);
  rb_define_alloc_func(SwigClassApplication.klass, _wrap_Application_allocate);
  rb_define_method(SwigClassApplication.klass, "initialize", VALUEFUNC(_wrap_new_Application), -1);
  rb_define_method(SwigClassApplication.klass, "onCreate", VALUEFUNC(_wrap_Application_onCreate), -1);
  rb_define_method(SwigClassApplication.klass, "onLogon", VALUEFUNC(_wrap_Application_onLogon), -1);
  rb_define_method(SwigClassApplication.klass, "onLogout", VALUEFUNC(_wrap_Application_onLogout), -1);
  rb_define_method(SwigClassApplication.klass, "toAdmin", VALUEFUNC(_wrap_Application_toAdmin), -1);
  rb_define_method(SwigClassApplication.klass, "toApp", VALUEFUNC(_wrap_Application_toApp), -1);
  rb_define_method(SwigClassApplication.klass, "fromAdmin", VALUEFUNC(_wrap_Application_fromAdmin), -1);
  rb_define_method(SwigClassApplication.klass, "fromApp", VALUEFUNC(_wrap_Application_fromApp), -1);
  SwigClassApplication.mark = 0;
  SwigClassApplication.destroy = (void (*)(void *)) free_FIX_Application;
  SwigClassApplication.trackObjects = 0;
  
  SwigClassSynchronizedApplication.klass = rb_define_class_under(mQuickfix, "SynchronizedApplication", ((swig_class *) SWIGTYPE_p_FIX__Application->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SynchronizedApplication, (void *) &SwigClassSynchronizedApplication);
  rb_define_alloc_func(SwigClassSynchronizedApplication.klass, _wrap_SynchronizedApplication_allocate);
  rb_define_method(SwigClassSynchronizedApplication.klass, "initialize", VALUEFUNC(_wrap_new_SynchronizedApplication), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "onCreate", VALUEFUNC(_wrap_SynchronizedApplication_onCreate), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "onLogon", VALUEFUNC(_wrap_SynchronizedApplication_onLogon), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "onLogout", VALUEFUNC(_wrap_SynchronizedApplication_onLogout), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "toAdmin", VALUEFUNC(_wrap_SynchronizedApplication_toAdmin), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "toApp", VALUEFUNC(_wrap_SynchronizedApplication_toApp), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "fromAdmin", VALUEFUNC(_wrap_SynchronizedApplication_fromAdmin), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "fromApp", VALUEFUNC(_wrap_SynchronizedApplication_fromApp), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "m_mutex=", VALUEFUNC(_wrap_SynchronizedApplication_m_mutex_set), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "m_mutex", VALUEFUNC(_wrap_SynchronizedApplication_m_mutex_get), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "app", VALUEFUNC(_wrap_SynchronizedApplication_app), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "m_app=", VALUEFUNC(_wrap_SynchronizedApplication_m_app_set), -1);
  rb_define_method(SwigClassSynchronizedApplication.klass, "m_app", VALUEFUNC(_wrap_SynchronizedApplication_m_app_get), -1);
  SwigClassSynchronizedApplication.mark = 0;
  SwigClassSynchronizedApplication.destroy = (void (*)(void *)) free_FIX_SynchronizedApplication;
  SwigClassSynchronizedApplication.trackObjects = 0;
  
  SwigClassNullApplication.klass = rb_define_class_under(mQuickfix, "NullApplication", ((swig_class *) SWIGTYPE_p_FIX__Application->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NullApplication, (void *) &SwigClassNullApplication);
  rb_define_alloc_func(SwigClassNullApplication.klass, _wrap_NullApplication_allocate);
  rb_define_method(SwigClassNullApplication.klass, "initialize", VALUEFUNC(_wrap_new_NullApplication), -1);
  SwigClassNullApplication.mark = 0;
  SwigClassNullApplication.destroy = (void (*)(void *)) free_FIX_NullApplication;
  SwigClassNullApplication.trackObjects = 0;
  
  SwigClassInitiator.klass = rb_define_class_under(mQuickfix, "Initiator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Initiator, (void *) &SwigClassInitiator);
  rb_undef_alloc_func(SwigClassInitiator.klass);
  rb_define_method(SwigClassInitiator.klass, "start", VALUEFUNC(_wrap_Initiator_start), -1);
  rb_define_method(SwigClassInitiator.klass, "block", VALUEFUNC(_wrap_Initiator_block), -1);
  rb_define_method(SwigClassInitiator.klass, "poll", VALUEFUNC(_wrap_Initiator_poll), -1);
  rb_define_method(SwigClassInitiator.klass, "stop", VALUEFUNC(_wrap_Initiator_stop), -1);
  rb_define_method(SwigClassInitiator.klass, "isLoggedOn", VALUEFUNC(_wrap_Initiator_isLoggedOn), -1);
  rb_define_method(SwigClassInitiator.klass, "getSessions", VALUEFUNC(_wrap_Initiator_getSessions), -1);
  rb_define_method(SwigClassInitiator.klass, "getSession", VALUEFUNC(_wrap_Initiator_getSession), -1);
  rb_define_method(SwigClassInitiator.klass, "getSessionSettings", VALUEFUNC(_wrap_Initiator_getSessionSettings), -1);
  rb_define_method(SwigClassInitiator.klass, "has", VALUEFUNC(_wrap_Initiator_has), -1);
  rb_define_method(SwigClassInitiator.klass, "isStopped", VALUEFUNC(_wrap_Initiator_isStopped), -1);
  rb_define_method(SwigClassInitiator.klass, "getApplication", VALUEFUNC(_wrap_Initiator_getApplication), -1);
  rb_define_method(SwigClassInitiator.klass, "getMessageStoreFactory", VALUEFUNC(_wrap_Initiator_getMessageStoreFactory), -1);
  rb_define_method(SwigClassInitiator.klass, "getLog", VALUEFUNC(_wrap_Initiator_getLog), -1);
  SwigClassInitiator.mark = 0;
  SwigClassInitiator.destroy = (void (*)(void *)) free_FIX_Initiator;
  SwigClassInitiator.trackObjects = 0;
  
  SwigClassSocketInitiatorBase.klass = rb_define_class_under(mQuickfix, "SocketInitiatorBase", ((swig_class *) SWIGTYPE_p_FIX__Initiator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketInitiator, (void *) &SwigClassSocketInitiatorBase);
  rb_define_alloc_func(SwigClassSocketInitiatorBase.klass, _wrap_SocketInitiatorBase_allocate);
  rb_define_method(SwigClassSocketInitiatorBase.klass, "initialize", VALUEFUNC(_wrap_new_SocketInitiatorBase), -1);
  SwigClassSocketInitiatorBase.mark = 0;
  SwigClassSocketInitiatorBase.destroy = (void (*)(void *)) free_FIX_SocketInitiator;
  SwigClassSocketInitiatorBase.trackObjects = 0;
  
  SwigClassAcceptor.klass = rb_define_class_under(mQuickfix, "Acceptor", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Acceptor, (void *) &SwigClassAcceptor);
  rb_undef_alloc_func(SwigClassAcceptor.klass);
  rb_define_method(SwigClassAcceptor.klass, "getLog", VALUEFUNC(_wrap_Acceptor_getLog), -1);
  rb_define_method(SwigClassAcceptor.klass, "start", VALUEFUNC(_wrap_Acceptor_start), -1);
  rb_define_method(SwigClassAcceptor.klass, "block", VALUEFUNC(_wrap_Acceptor_block), -1);
  rb_define_method(SwigClassAcceptor.klass, "poll", VALUEFUNC(_wrap_Acceptor_poll), -1);
  rb_define_method(SwigClassAcceptor.klass, "stop", VALUEFUNC(_wrap_Acceptor_stop), -1);
  rb_define_method(SwigClassAcceptor.klass, "isLoggedOn", VALUEFUNC(_wrap_Acceptor_isLoggedOn), -1);
  rb_define_method(SwigClassAcceptor.klass, "getSessions", VALUEFUNC(_wrap_Acceptor_getSessions), -1);
  rb_define_method(SwigClassAcceptor.klass, "getSession", VALUEFUNC(_wrap_Acceptor_getSession), -1);
  rb_define_method(SwigClassAcceptor.klass, "getSessionSettings", VALUEFUNC(_wrap_Acceptor_getSessionSettings), -1);
  rb_define_method(SwigClassAcceptor.klass, "has", VALUEFUNC(_wrap_Acceptor_has), -1);
  rb_define_method(SwigClassAcceptor.klass, "isStopped", VALUEFUNC(_wrap_Acceptor_isStopped), -1);
  rb_define_method(SwigClassAcceptor.klass, "getApplication", VALUEFUNC(_wrap_Acceptor_getApplication), -1);
  rb_define_method(SwigClassAcceptor.klass, "getMessageStoreFactory", VALUEFUNC(_wrap_Acceptor_getMessageStoreFactory), -1);
  SwigClassAcceptor.mark = 0;
  SwigClassAcceptor.destroy = (void (*)(void *)) free_FIX_Acceptor;
  SwigClassAcceptor.trackObjects = 0;
  
  SwigClassSocketAcceptorBase.klass = rb_define_class_under(mQuickfix, "SocketAcceptorBase", ((swig_class *) SWIGTYPE_p_FIX__Acceptor->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketAcceptor, (void *) &SwigClassSocketAcceptorBase);
  rb_define_alloc_func(SwigClassSocketAcceptorBase.klass, _wrap_SocketAcceptorBase_allocate);
  rb_define_method(SwigClassSocketAcceptorBase.klass, "initialize", VALUEFUNC(_wrap_new_SocketAcceptorBase), -1);
  SwigClassSocketAcceptorBase.mark = 0;
  SwigClassSocketAcceptorBase.destroy = (void (*)(void *)) free_FIX_SocketAcceptor;
  SwigClassSocketAcceptorBase.trackObjects = 0;
  
  SwigClassDataDictionary.klass = rb_define_class_under(mQuickfix, "DataDictionary", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DataDictionary, (void *) &SwigClassDataDictionary);
  rb_define_alloc_func(SwigClassDataDictionary.klass, _wrap_DataDictionary_allocate);
  rb_define_method(SwigClassDataDictionary.klass, "initialize", VALUEFUNC(_wrap_new_DataDictionary), -1);
  rb_define_method(SwigClassDataDictionary.klass, "readFromURL", VALUEFUNC(_wrap_DataDictionary_readFromURL), -1);
  rb_define_method(SwigClassDataDictionary.klass, "readFromDocument", VALUEFUNC(_wrap_DataDictionary_readFromDocument), -1);
  rb_define_method(SwigClassDataDictionary.klass, "readFromStream", VALUEFUNC(_wrap_DataDictionary_readFromStream), -1);
  rb_define_method(SwigClassDataDictionary.klass, "getOrderedFields", VALUEFUNC(_wrap_DataDictionary_getOrderedFields), -1);
  rb_define_method(SwigClassDataDictionary.klass, "setVersion", VALUEFUNC(_wrap_DataDictionary_setVersion), -1);
  rb_define_method(SwigClassDataDictionary.klass, "getVersion", VALUEFUNC(_wrap_DataDictionary_getVersion), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addField", VALUEFUNC(_wrap_DataDictionary_addField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addFieldName", VALUEFUNC(_wrap_DataDictionary_addFieldName), -1);
  rb_define_method(SwigClassDataDictionary.klass, "_getFieldName", VALUEFUNC(_wrap_DataDictionary__getFieldName), -1);
  rb_define_method(SwigClassDataDictionary.klass, "_getFieldTag", VALUEFUNC(_wrap_DataDictionary__getFieldTag), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addValueName", VALUEFUNC(_wrap_DataDictionary_addValueName), -1);
  rb_define_method(SwigClassDataDictionary.klass, "_getValueName", VALUEFUNC(_wrap_DataDictionary__getValueName), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isField", VALUEFUNC(_wrap_DataDictionary_isField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addMsgType", VALUEFUNC(_wrap_DataDictionary_addMsgType), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isMsgType", VALUEFUNC(_wrap_DataDictionary_isMsgType), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addMsgField", VALUEFUNC(_wrap_DataDictionary_addMsgField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isMsgField", VALUEFUNC(_wrap_DataDictionary_isMsgField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addHeaderField", VALUEFUNC(_wrap_DataDictionary_addHeaderField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isHeaderField", VALUEFUNC(_wrap_DataDictionary_isHeaderField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addTrailerField", VALUEFUNC(_wrap_DataDictionary_addTrailerField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isTrailerField", VALUEFUNC(_wrap_DataDictionary_isTrailerField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addFieldType", VALUEFUNC(_wrap_DataDictionary_addFieldType), -1);
  rb_define_method(SwigClassDataDictionary.klass, "getFieldType", VALUEFUNC(_wrap_DataDictionary_getFieldType), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addRequiredField", VALUEFUNC(_wrap_DataDictionary_addRequiredField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isRequiredField", VALUEFUNC(_wrap_DataDictionary_isRequiredField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addFieldValue", VALUEFUNC(_wrap_DataDictionary_addFieldValue), -1);
  rb_define_method(SwigClassDataDictionary.klass, "hasFieldValue", VALUEFUNC(_wrap_DataDictionary_hasFieldValue), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isFieldValue", VALUEFUNC(_wrap_DataDictionary_isFieldValue), -1);
  rb_define_method(SwigClassDataDictionary.klass, "addGroup", VALUEFUNC(_wrap_DataDictionary_addGroup), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isGroup", VALUEFUNC(_wrap_DataDictionary_isGroup), -1);
  rb_define_method(SwigClassDataDictionary.klass, "_getGroup", VALUEFUNC(_wrap_DataDictionary__getGroup), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isDataField", VALUEFUNC(_wrap_DataDictionary_isDataField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "isMultipleValueField", VALUEFUNC(_wrap_DataDictionary_isMultipleValueField), -1);
  rb_define_method(SwigClassDataDictionary.klass, "checkFieldsOutOfOrder", VALUEFUNC(_wrap_DataDictionary_checkFieldsOutOfOrder), -1);
  rb_define_method(SwigClassDataDictionary.klass, "checkFieldsHaveValues", VALUEFUNC(_wrap_DataDictionary_checkFieldsHaveValues), -1);
  rb_define_method(SwigClassDataDictionary.klass, "checkUserDefinedFields", VALUEFUNC(_wrap_DataDictionary_checkUserDefinedFields), -1);
  rb_define_method(SwigClassDataDictionary.klass, "validate", VALUEFUNC(_wrap_DataDictionary_validate), -1);
  SwigClassDataDictionary.mark = 0;
  SwigClassDataDictionary.destroy = (void (*)(void *)) free_FIX_DataDictionary;
  SwigClassDataDictionary.trackObjects = 0;
  
#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
  
}